extend op-node to support holocene 1559 params

bedrock-devnet/devnet/__init__.py

@@ -24,7 +24,7 @@
 log = logging.getLogger()
 
 # Global constants
-FORKS = ["delta", "ecotone", "fjord", "granite"]
+FORKS = ["delta", "ecotone", "fjord", "granite", "holocene"]
 
 # Global environment variables
 DEVNET_NO_BUILD = os.getenv('DEVNET_NO_BUILD') == "true"

go.mod

@@ -251,9 +251,9 @@ require (
 	rsc.io/tmplfunc v0.0.3 // indirect
 )
 
-replace github.com/ethereum/go-ethereum v1.14.11 => github.com/ethereum-optimism/op-geth v1.101408.1-0.20241002211323-d5a96613c22b
+replace github.com/ethereum/go-ethereum v1.14.11 => github.com/ethereum-optimism/op-geth v1.101411.1-rc.1
 
-// replace github.com/ethereum/go-ethereum => ../op-geth
+//replace github.com/ethereum/go-ethereum => ../op-geth
 
 // replace github.com/ethereum-optimism/superchain-registry/superchain => ../superchain-registry/superchain
 

go.sum

@@ -181,8 +181,8 @@ github.com/elastic/gosigar v0.14.3 h1:xwkKwPia+hSfg9GqrCUKYdId102m9qTJIIr7egmK/u
 github.com/elastic/gosigar v0.14.3/go.mod h1:iXRIGg2tLnu7LBdpqzyQfGDEidKCfWcCMS0WKyPWoMs=
 github.com/ethereum-optimism/go-ethereum-hdwallet v0.1.3 h1:RWHKLhCrQThMfch+QJ1Z8veEq5ZO3DfIhZ7xgRP9WTc=
 github.com/ethereum-optimism/go-ethereum-hdwallet v0.1.3/go.mod h1:QziizLAiF0KqyLdNJYD7O5cpDlaFMNZzlxYNcWsJUxs=
-github.com/ethereum-optimism/op-geth v1.101408.1-0.20241002211323-d5a96613c22b h1:9C6WytqAcqWKXQTMw2Da/S/aIJJmMvT+2MUpFnMdGrg=
-github.com/ethereum-optimism/op-geth v1.101408.1-0.20241002211323-d5a96613c22b/go.mod h1:7S4pp8KHBmEmKkRjL1BPOc6jY9hW+64YeMUjR3RVLw4=
+github.com/ethereum-optimism/op-geth v1.101411.1-rc.1 h1:HhvjQQIY73Rhkf3CtcNLuL87A7z/us78ft4m84BuZes=
+github.com/ethereum-optimism/op-geth v1.101411.1-rc.1/go.mod h1:7S4pp8KHBmEmKkRjL1BPOc6jY9hW+64YeMUjR3RVLw4=
 github.com/ethereum-optimism/superchain-registry/superchain v0.0.0-20240910145426-b3905c89e8ac h1:hCIrLuOPV3FJfMDvXeOhCC3uQNvFoMIIlkT2mN2cfeg=
 github.com/ethereum-optimism/superchain-registry/superchain v0.0.0-20240910145426-b3905c89e8ac/go.mod h1:XaVXL9jg8BcyOeugECgIUGa9Y3DjYJj71RHmb5qon6M=
 github.com/ethereum/c-kzg-4844 v1.0.0 h1:0X1LBXxaEtYD9xsyj9B9ctQEZIpnvVDeoBx8aHEwTNA=

op-chain-ops/genesis/config.go

@@ -94,8 +94,8 @@ type L2GenesisBlockDeployConfig struct {
 	L2GenesisBlockGasUsed       hexutil.Uint64 `json:"l2GenesisBlockGasUsed"`
 	L2GenesisBlockParentHash    common.Hash    `json:"l2GenesisBlockParentHash"`
 	L2GenesisBlockBaseFeePerGas *hexutil.Big   `json:"l2GenesisBlockBaseFeePerGas"`
-	// L2GenesisBlockExtraData is configurable extradata. Will default to []byte("BEDROCK") if left unspecified.
-	L2GenesisBlockExtraData []byte `json:"l2GenesisBlockExtraData"`
+	// Note that there is no L2 genesis ExtraData, as it must default to a valid Holocene eip-1559
+	// configuration. See constant 'HoloceneExtraData' for the specific value used.
 	// Note that there is no L2 genesis timestamp:
 	// This is instead configured based on the timestamp of "l1StartingBlockTag".
 }
@@ -342,6 +342,9 @@ type UpgradeScheduleDeployConfig struct {
 	// L2GenesisGraniteTimeOffset is the number of seconds after genesis block that Granite hard fork activates.
 	// Set it to 0 to activate at genesis. Nil to disable Granite.
 	L2GenesisGraniteTimeOffset *hexutil.Uint64 `json:"l2GenesisGraniteTimeOffset,omitempty"`
+	// L2GenesisHoloceneTimeOffset is the number of seconds after genesis block that the Holocene hard fork activates.
+	// Set it to 0 to activate at genesis. Nil to disable Holocene.
+	L2GenesisHoloceneTimeOffset *hexutil.Uint64 `json:"l2GenesisHoloceneTimeOffset,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"`
@@ -390,6 +393,10 @@ func (d *UpgradeScheduleDeployConfig) GraniteTime(genesisTime uint64) *uint64 {
 	return offsetToUpgradeTime(d.L2GenesisGraniteTimeOffset, genesisTime)
 }
 
+func (d *UpgradeScheduleDeployConfig) HoloceneTime(genesisTime uint64) *uint64 {
+	return offsetToUpgradeTime(d.L2GenesisHoloceneTimeOffset, genesisTime)
+}
+
 func (d *UpgradeScheduleDeployConfig) InteropTime(genesisTime uint64) *uint64 {
 	return offsetToUpgradeTime(d.L2GenesisInteropTimeOffset, genesisTime)
 }
@@ -422,6 +429,7 @@ func (d *UpgradeScheduleDeployConfig) forks() []Fork {
 		{L2GenesisTimeOffset: d.L2GenesisEcotoneTimeOffset, Name: string(L2AllocsEcotone)},
 		{L2GenesisTimeOffset: d.L2GenesisFjordTimeOffset, Name: string(L2AllocsFjord)},
 		{L2GenesisTimeOffset: d.L2GenesisGraniteTimeOffset, Name: string(L2AllocsGranite)},
+		{L2GenesisTimeOffset: d.L2GenesisHoloceneTimeOffset, Name: string(L2AllocsHolocene)},
 	}
 }
 
@@ -931,6 +939,7 @@ func (d *DeployConfig) RollupConfig(l1StartBlock *types.Header, l2GenesisBlockHa
 		EcotoneTime:             d.EcotoneTime(l1StartTime),
 		FjordTime:               d.FjordTime(l1StartTime),
 		GraniteTime:             d.GraniteTime(l1StartTime),
+		HoloceneTime:            d.HoloceneTime(l1StartTime),
 		InteropTime:             d.InteropTime(l1StartTime),
 		ProtocolVersionsAddress: d.ProtocolVersionsProxy,
 		AltDAConfig:             altDA,

op-chain-ops/genesis/config_test.go

@@ -24,8 +24,6 @@ func TestConfigDataMarshalUnmarshal(t *testing.T) {
 	dec := json.NewDecoder(bytes.NewReader(b))
 	decoded := new(DeployConfig)
 	require.NoError(t, dec.Decode(decoded))
-	require.EqualValues(t, "non-default value", string(decoded.L2GenesisBlockExtraData))
-
 	require.NoError(t, decoded.Check(testlog.Logger(t, log.LevelDebug)))
 
 	encoded, err := json.MarshalIndent(decoded, "", "  ")

op-chain-ops/genesis/genesis.go

@@ -2,13 +2,13 @@ package genesis
 
 import (
 	"errors"
-	"fmt"
 	"math/big"
 	"time"
 
 	"github.com/ethereum-optimism/optimism/op-service/predeploys"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/common/hexutil"
+	"github.com/ethereum/go-ethereum/consensus/misc/eip1559"
 	"github.com/ethereum/go-ethereum/core"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/crypto"
@@ -18,8 +18,8 @@ import (
 // defaultGasLimit represents the default gas limit for a genesis block.
 const defaultGasLimit = 30_000_000
 
-// BedrockTransitionBlockExtraData represents the default extra data for the bedrock transition block.
-var BedrockTransitionBlockExtraData = []byte("BEDROCK")
+// HoloceneExtraData represents the default extra data for Holocene-genesis chains.
+var HoloceneExtraData = eip1559.EncodeHoloceneExtraData(250, 6)
 
 // NewL2Genesis will create a new L2 genesis
 func NewL2Genesis(config *DeployConfig, l1StartHeader *types.Header) (*core.Genesis, error) {
@@ -70,6 +70,7 @@ func NewL2Genesis(config *DeployConfig, l1StartHeader *types.Header) (*core.Gene
 		EcotoneTime:                   config.EcotoneTime(l1StartTime),
 		FjordTime:                     config.FjordTime(l1StartTime),
 		GraniteTime:                   config.GraniteTime(l1StartTime),
+		HoloceneTime:                  config.HoloceneTime(l1StartTime),
 		InteropTime:                   config.InteropTime(l1StartTime),
 		Optimism: &params.OptimismConfig{
 			EIP1559Denominator:       eip1559Denom,
@@ -91,21 +92,10 @@ func NewL2Genesis(config *DeployConfig, l1StartHeader *types.Header) (*core.Gene
 		difficulty = newHexBig(0)
 	}
 
-	extraData := config.L2GenesisBlockExtraData
-	if extraData == nil {
-		// L2GenesisBlockExtraData is optional, so use a default value when nil
-		extraData = BedrockTransitionBlockExtraData
-	}
-	// Ensure that the extradata is valid
-	if size := len(extraData); size > 32 {
-		return nil, fmt.Errorf("transition block extradata too long: %d", size)
-	}
-
 	genesis := &core.Genesis{
 		Config:     &optimismChainConfig,
 		Nonce:      uint64(config.L2GenesisBlockNonce),
 		Timestamp:  l1StartTime,
-		ExtraData:  extraData,
 		GasLimit:   uint64(gasLimit),
 		Difficulty: difficulty.ToInt(),
 		Mixhash:    config.L2GenesisBlockMixHash,
@@ -121,6 +111,9 @@ func NewL2Genesis(config *DeployConfig, l1StartHeader *types.Header) (*core.Gene
 		genesis.BlobGasUsed = u64ptr(0)
 		genesis.ExcessBlobGas = u64ptr(0)
 	}
+	if optimismChainConfig.IsHolocene(genesis.Timestamp) {
+		genesis.ExtraData = HoloceneExtraData
+	}
 
 	return genesis, nil
 }

op-chain-ops/genesis/layer_two.go

@@ -22,10 +22,11 @@ type L2AllocsMode string
 type L2AllocsModeMap map[L2AllocsMode]*foundry.ForgeAllocs
 
 const (
-	L2AllocsDelta   L2AllocsMode = "delta"
-	L2AllocsEcotone L2AllocsMode = "ecotone"
-	L2AllocsFjord   L2AllocsMode = "fjord"
-	L2AllocsGranite L2AllocsMode = "granite"
+	L2AllocsDelta    L2AllocsMode = "delta"
+	L2AllocsEcotone  L2AllocsMode = "ecotone"
+	L2AllocsFjord    L2AllocsMode = "fjord"
+	L2AllocsGranite  L2AllocsMode = "granite"
+	L2AllocsHolocene L2AllocsMode = "holocene"
 )
 
 var (

op-chain-ops/genesis/testdata/test-deploy-config-full.json

@@ -39,7 +39,6 @@
   "l2GenesisBlockGasUsed": "0x0",
   "l2GenesisBlockParentHash": "0x0000000000000000000000000000000000000000000000000000000000000000",
   "l2GenesisBlockBaseFeePerGas": "0x3b9aca00",
-  "l2GenesisBlockExtraData": "bm9uLWRlZmF1bHQgdmFsdWU=",
   "baseFeeVaultRecipient": "0x42000000000000000000000000000000000000f5",
   "l1FeeVaultRecipient": "0x42000000000000000000000000000000000000f6",
   "sequencerFeeVaultRecipient": "0x42000000000000000000000000000000000000f7",

op-chain-ops/interopgen/deploy.go

@@ -130,7 +130,7 @@ func CreateL2(logger log.Logger, fa *foundry.ArtifactsFS, srcFS *foundry.SourceM
 	}
 	l2Host := script.NewHost(logger.New("role", "l2", "chain", l2Cfg.L2ChainID), fa, srcFS, l2Context)
 	l2Host.SetEnvVar("OUTPUT_MODE", "none") // we don't use the cheatcode, but capture the state outside of EVM execution
-	l2Host.SetEnvVar("FORK", "granite")     // latest fork
+	l2Host.SetEnvVar("FORK", "holocene")    // latest fork
 	return l2Host
 }
 

op-chain-ops/interopgen/recipe.go

@@ -232,6 +232,7 @@ func InteropL2DevConfig(l1ChainID, l2ChainID uint64, addrs devkeys.Addresses) (*
 				L2GenesisEcotoneTimeOffset:  new(hexutil.Uint64),
 				L2GenesisFjordTimeOffset:    new(hexutil.Uint64),
 				L2GenesisGraniteTimeOffset:  new(hexutil.Uint64),
+				L2GenesisHoloceneTimeOffset: new(hexutil.Uint64),
 				L2GenesisInteropTimeOffset:  new(hexutil.Uint64),
 				L1CancunTimeOffset:          new(hexutil.Uint64),
 				UseInterop:                  true,

op-chain-ops/script/script.go

@@ -206,6 +206,7 @@ func NewHost(
 		EcotoneTime:  nil,
 		FjordTime:    nil,
 		GraniteTime:  nil,
+		HoloceneTime: nil,
 		InteropTime:  nil,
 		Optimism:     nil,
 	}

op-deployer/pkg/deployer/state/deploy_config.go

@@ -57,6 +57,7 @@ func DefaultDeployConfig(chainIntent *ChainIntent) genesis.DeployConfig {
 				L2GenesisEcotoneTimeOffset:  u64UtilPtr(0),
 				L2GenesisFjordTimeOffset:    u64UtilPtr(0),
 				L2GenesisGraniteTimeOffset:  u64UtilPtr(0),
+				L2GenesisHoloceneTimeOffset: u64UtilPtr(0),
 				UseInterop:                  false,
 			},
 			L2CoreDeployConfig: genesis.L2CoreDeployConfig{

op-e2e/actions/derivation/system_config_test.go

@@ -237,6 +237,7 @@ func GPOParamsChange(gt *testing.T, deltaTimeOffset *hexutil.Uint64) {
 	dp.DeployConfig.L2GenesisEcotoneTimeOffset = nil
 	dp.DeployConfig.L2GenesisFjordTimeOffset = nil
 	dp.DeployConfig.L2GenesisGraniteTimeOffset = nil
+	dp.DeployConfig.L2GenesisHoloceneTimeOffset = nil
 
 	sd := e2eutils.Setup(t, dp, actionsHelpers.DefaultAlloc)
 	log := testlog.Logger(t, log.LevelDebug)

op-e2e/actions/helpers/l2_sequencer.go

@@ -213,3 +213,11 @@ func (s *L2Sequencer) ActBuildL2ToGranite(t Testing) {
 		s.ActL2EndBlock(t)
 	}
 }
+
+func (s *L2Sequencer) ActBuildL2ToHolocene(t Testing) {
+	require.NotNil(t, s.RollupCfg.HoloceneTime, "cannot activate HoloceneTime when it is not scheduled")
+	for s.L2Unsafe().Time < *s.RollupCfg.HoloceneTime {
+		s.ActL2StartBlock(t)
+		s.ActL2EndBlock(t)
+	}
+}

op-e2e/actions/helpers/user_test.go

@@ -25,6 +25,8 @@ type hardforkScheduledTest struct {
 	deltaTime    *hexutil.Uint64
 	ecotoneTime  *hexutil.Uint64
 	fjordTime    *hexutil.Uint64
+	graniteTime  *hexutil.Uint64
+	holoceneTime *hexutil.Uint64
 	runToFork    string
 	allocType    config.AllocType
 }
@@ -39,6 +41,10 @@ func (tc *hardforkScheduledTest) GetFork(fork string) *uint64 {
 
 func (tc *hardforkScheduledTest) fork(fork string) **hexutil.Uint64 {
 	switch fork {
+	case "holocene":
+		return &tc.holoceneTime
+	case "granite":
+		return &tc.graniteTime
 	case "fjord":
 		return &tc.fjordTime
 	case "ecotone":
@@ -80,6 +86,8 @@ func testCrossLayerUser(t *testing.T, allocType config.AllocType) {
 		"delta",
 		"ecotone",
 		"fjord",
+		"granite",
+		"holocene",
 	}
 	for i, fork := range forks {
 		i := i
@@ -136,6 +144,8 @@ func runCrossLayerUserTest(gt *testing.T, test hardforkScheduledTest) {
 	dp.DeployConfig.L2GenesisDeltaTimeOffset = test.deltaTime
 	dp.DeployConfig.L2GenesisEcotoneTimeOffset = test.ecotoneTime
 	dp.DeployConfig.L2GenesisFjordTimeOffset = test.fjordTime
+	dp.DeployConfig.L2GenesisGraniteTimeOffset = test.graniteTime
+	dp.DeployConfig.L2GenesisHoloceneTimeOffset = test.holoceneTime
 
 	if test.canyonTime != nil {
 		require.Zero(t, uint64(*test.canyonTime)%uint64(dp.DeployConfig.L2BlockTime), "canyon fork must be aligned")

op-e2e/actions/proofs/helpers/env.go

@@ -61,6 +61,8 @@ func NewL2FaultProofEnv[c any](t helpers.Testing, testCfg *TestCfg[c], tp *e2eut
 			dp.DeployConfig.L2GenesisFjordTimeOffset = &genesisBlock
 		case Granite:
 			dp.DeployConfig.L2GenesisGraniteTimeOffset = &genesisBlock
+		case Holocene:
+			dp.DeployConfig.L2GenesisHoloceneTimeOffset = &genesisBlock
 		}
 	})
 	sd := e2eutils.Setup(t, dp, helpers.DefaultAlloc)

op-e2e/actions/proofs/helpers/matrix.go

@@ -84,11 +84,12 @@ var (
 	Regolith = &Hardfork{Name: "Regolith", Precedence: 1}
 	Canyon   = &Hardfork{Name: "Canyon", Precedence: 2}
 	Delta    = &Hardfork{Name: "Delta", Precedence: 3}
-	Fjord    = &Hardfork{Name: "Fjord", Precedence: 4}
-	Ecotone  = &Hardfork{Name: "Ecotone", Precedence: 5}
+	Ecotone  = &Hardfork{Name: "Ecotone", Precedence: 4}
+	Fjord    = &Hardfork{Name: "Fjord", Precedence: 5}
 	Granite  = &Hardfork{Name: "Granite", Precedence: 6}
+	Holocene = &Hardfork{Name: "Holocene", Precedence: 7}
 )
-var Hardforks = ForkMatrix{Regolith, Canyon, Delta, Fjord, Ecotone, Granite}
+var Hardforks = ForkMatrix{Regolith, Canyon, Delta, Ecotone, Fjord, Granite, Holocene}
 
 var LatestForkOnly = ForkMatrix{Hardforks[len(Hardforks)-1]}
 

op-e2e/actions/upgrades/dencun_fork_test.go

@@ -126,6 +126,7 @@ func TestDencunL2ForkAfterGenesis(gt *testing.T) {
 	dp.DeployConfig.L2GenesisEcotoneTimeOffset = &offset
 	dp.DeployConfig.L2GenesisFjordTimeOffset = nil
 	dp.DeployConfig.L2GenesisGraniteTimeOffset = nil
+	dp.DeployConfig.L2GenesisHoloceneTimeOffset = nil
 	// New forks have to be added here, after changing the default deploy config!
 
 	sd := e2eutils.Setup(t, dp, helpers.DefaultAlloc)

op-e2e/actions/upgrades/ecotone_fork_test.go

@@ -52,6 +52,7 @@ func TestEcotoneNetworkUpgradeTransactions(gt *testing.T) {
 	dp.DeployConfig.L2GenesisEcotoneTimeOffset = &ecotoneOffset
 	dp.DeployConfig.L2GenesisFjordTimeOffset = nil
 	dp.DeployConfig.L2GenesisGraniteTimeOffset = nil
+	dp.DeployConfig.L2GenesisHoloceneTimeOffset = nil
 	// New forks have to be added here...
 	require.NoError(t, dp.DeployConfig.Check(log), "must have valid config")
 

op-e2e/actions/upgrades/fjord_fork_test.go

@@ -45,6 +45,7 @@ func TestFjordNetworkUpgradeTransactions(gt *testing.T) {
 	dp.DeployConfig.L2GenesisDeltaTimeOffset = &genesisBlock
 	dp.DeployConfig.L2GenesisEcotoneTimeOffset = &genesisBlock
 	dp.DeployConfig.L2GenesisFjordTimeOffset = &fjordOffset
+	dp.DeployConfig.L2GenesisGraniteTimeOffset = nil
 	require.NoError(t, dp.DeployConfig.Check(log), "must have valid config")
 
 	sd := e2eutils.Setup(t, dp, helpers.DefaultAlloc)

op-e2e/actions/upgrades/helpers/config.go

@@ -8,6 +8,7 @@ import (
 // ApplyDeltaTimeOffset adjusts fork configuration to not conflict with the delta overrides
 func ApplyDeltaTimeOffset(dp *e2eutils.DeployParams, deltaTimeOffset *hexutil.Uint64) {
 	dp.DeployConfig.L2GenesisDeltaTimeOffset = deltaTimeOffset
+	dp.DeployConfig.L2GenesisGraniteTimeOffset = nil
 	// configure Ecotone to not be before Delta accidentally
 	if dp.DeployConfig.L2GenesisEcotoneTimeOffset != nil {
 		if deltaTimeOffset == nil {

op-e2e/actions/upgrades/span_batch_test.go

@@ -142,6 +142,7 @@ func TestHardforkMiddleOfSpanBatch(gt *testing.T) {
 	dp.DeployConfig.L2GenesisEcotoneTimeOffset = nil
 	dp.DeployConfig.L2GenesisFjordTimeOffset = nil
 	dp.DeployConfig.L2GenesisGraniteTimeOffset = nil
+	dp.DeployConfig.L2GenesisHoloceneTimeOffset = nil
 
 	sd := e2eutils.Setup(t, dp, actionsHelpers.DefaultAlloc)
 	log := testlog.Logger(t, log.LevelError)

op-e2e/config/init.go

@@ -185,6 +185,7 @@ func initAllocType(root string, allocType AllocType) {
 		}
 		l2Alloc[mode] = allocs
 	}
+	mustL2Allocs(genesis.L2AllocsHolocene)
 	mustL2Allocs(genesis.L2AllocsGranite)
 	mustL2Allocs(genesis.L2AllocsFjord)
 	mustL2Allocs(genesis.L2AllocsEcotone)