Fusaka fixes

op-batcher/batcher/channel_builder_test.go

@@ -16,6 +16,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-service/eth"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
+	"github.com/ethereum/go-ethereum/params"
 	"github.com/ethereum/go-ethereum/trie"
 
 	"github.com/stretchr/testify/require"
@@ -76,7 +77,7 @@ func newMiniL2BlockWithNumberParentAndL1Information(numTx int, l2Number *big.Int
 		Number:     big.NewInt(l1Number),
 		Time:       blockTime,
 	}, nil, nil, trie.NewStackTrie(nil), types.DefaultBlockConfig)
-	l1InfoTx, err := derive.L1InfoDeposit(defaultTestRollupConfig, eth.SystemConfig{}, 0, eth.BlockToInfo(l1Block), blockTime)
+	l1InfoTx, err := derive.L1InfoDeposit(defaultTestRollupConfig, params.MergedTestChainConfig, eth.SystemConfig{}, 0, eth.BlockToInfo(l1Block), blockTime)
 	if err != nil {
 		panic(err)
 	}

op-chain-ops/cmd/check-ecotone/main.go

@@ -512,7 +512,7 @@ func checkBlobTxDenial(ctx context.Context, env *actionEnv) error {
 		return fmt.Errorf("the L1 block %s (time %d) is not ecotone yet", latestHeader.Hash(), latestHeader.Time)
 	}
 
-	blobBaseFee := eth.CalcBlobFeeDefault(latestHeader)
+	blobBaseFee := eth.CalcBlobFeeCancun(*latestHeader.ExcessBlobGas)
 	blobFeeCap := new(uint256.Int).Mul(uint256.NewInt(2), uint256.MustFromBig(blobBaseFee))
 	if blobFeeCap.Lt(uint256.NewInt(params.GWei)) { // ensure we meet 1 gwei geth tx-pool minimum
 		blobFeeCap = uint256.NewInt(params.GWei)

op-challenger/config/config_test.go

@@ -6,6 +6,7 @@ import (
 	"os"
 	"path/filepath"
 	"runtime"
+	"slices"
 	"testing"
 
 	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/trace/vm"
@@ -144,6 +145,28 @@ func validConfig(t *testing.T, traceType types.TraceType) Config {
 	return cfg
 }
 
+func validConfigWithNoNetworks(t *testing.T, traceType types.TraceType) Config {
+	cfg := validConfig(t, traceType)
+
+	mutateVmConfig := func(cfg *vm.Config) {
+		cfg.Networks = nil
+		cfg.RollupConfigPaths = []string{"foo.json"}
+		cfg.L2GenesisPaths = []string{"genesis.json"}
+		cfg.L1GenesisPath = "bar.json"
+		cfg.DepsetConfigPath = "foo.json"
+	}
+	if slices.Contains(allCannonTraceTypes, traceType) {
+		mutateVmConfig(&cfg.Cannon)
+	}
+	if slices.Contains(asteriscTraceTypes, traceType) {
+		mutateVmConfig(&cfg.Asterisc)
+	}
+	if slices.Contains(asteriscKonaTraceTypes, traceType) {
+		mutateVmConfig(&cfg.AsteriscKona)
+	}
+	return cfg
+}
+
 // TestValidConfigIsValid checks that the config provided by validConfig is actually valid
 func TestValidConfigIsValid(t *testing.T) {
 	for _, traceType := range types.TraceTypes {
@@ -261,20 +284,14 @@ func TestCannonRequiredArgs(t *testing.T) {
 		})
 
 		t.Run(fmt.Sprintf("TestCannonNetworkOrRollupConfigRequired-%v", traceType), func(t *testing.T) {
-			cfg := validConfig(t, traceType)
-			cfg.Cannon.Networks = nil
+			cfg := validConfigWithNoNetworks(t, traceType)
 			cfg.Cannon.RollupConfigPaths = nil
-			cfg.Cannon.L2GenesisPaths = []string{"genesis.json"}
-			cfg.Cannon.DepsetConfigPath = "foo.json"
 			require.ErrorIs(t, cfg.Check(), vm.ErrMissingRollupConfig)
 		})
 
 		t.Run(fmt.Sprintf("TestCannonNetworkOrL2GenesisRequired-%v", traceType), func(t *testing.T) {
-			cfg := validConfig(t, traceType)
-			cfg.Cannon.Networks = nil
-			cfg.Cannon.RollupConfigPaths = []string{"foo.json"}
+			cfg := validConfigWithNoNetworks(t, traceType)
 			cfg.Cannon.L2GenesisPaths = nil
-			cfg.Cannon.DepsetConfigPath = "foo.json"
 			require.ErrorIs(t, cfg.Check(), vm.ErrMissingL2Genesis)
 		})
 
@@ -354,6 +371,7 @@ func TestDepsetConfig(t *testing.T) {
 			cfg := validConfig(t, traceType)
 			cfg.Cannon.Networks = nil
 			cfg.Cannon.RollupConfigPaths = []string{"foo.json"}
+			cfg.Cannon.L1GenesisPath = "bar.json"
 			cfg.Cannon.L2GenesisPaths = []string{"genesis.json"}
 			cfg.Cannon.DepsetConfigPath = ""
 			require.NoError(t, cfg.Check())
@@ -366,6 +384,7 @@ func TestDepsetConfig(t *testing.T) {
 			cfg := validConfig(t, traceType)
 			cfg.AsteriscKona.Networks = nil
 			cfg.AsteriscKona.RollupConfigPaths = []string{"foo.json"}
+			cfg.AsteriscKona.L1GenesisPath = "bar.json"
 			cfg.AsteriscKona.L2GenesisPaths = []string{"genesis.json"}
 			cfg.AsteriscKona.DepsetConfigPath = ""
 			require.NoError(t, cfg.Check())
@@ -441,17 +460,13 @@ func TestAsteriscRequiredArgs(t *testing.T) {
 		})
 
 		t.Run(fmt.Sprintf("TestAsteriscNetworkOrRollupConfigRequired-%v", traceType), func(t *testing.T) {
-			cfg := validConfig(t, traceType)
-			cfg.Asterisc.Networks = nil
+			cfg := validConfigWithNoNetworks(t, traceType)
 			cfg.Asterisc.RollupConfigPaths = nil
-			cfg.Asterisc.L2GenesisPaths = []string{"genesis.json"}
 			require.ErrorIs(t, cfg.Check(), vm.ErrMissingRollupConfig)
 		})
 
 		t.Run(fmt.Sprintf("TestAsteriscNetworkOrL2GenesisRequired-%v", traceType), func(t *testing.T) {
-			cfg := validConfig(t, traceType)
-			cfg.Asterisc.Networks = nil
-			cfg.Asterisc.RollupConfigPaths = []string{"foo.json"}
+			cfg := validConfigWithNoNetworks(t, traceType)
 			cfg.Asterisc.L2GenesisPaths = nil
 			require.ErrorIs(t, cfg.Check(), vm.ErrMissingL2Genesis)
 		})
@@ -557,17 +572,13 @@ func TestAsteriscKonaRequiredArgs(t *testing.T) {
 		})
 
 		t.Run(fmt.Sprintf("TestAsteriscKonaNetworkOrRollupConfigRequired-%v", traceType), func(t *testing.T) {
-			cfg := validConfig(t, traceType)
-			cfg.AsteriscKona.Networks = nil
+			cfg := validConfigWithNoNetworks(t, traceType)
 			cfg.AsteriscKona.RollupConfigPaths = nil
-			cfg.AsteriscKona.L2GenesisPaths = []string{"genesis.json"}
 			require.ErrorIs(t, cfg.Check(), vm.ErrMissingRollupConfig)
 		})
 
 		t.Run(fmt.Sprintf("TestAsteriscKonaNetworkOrL2GenesisRequired-%v", traceType), func(t *testing.T) {
-			cfg := validConfig(t, traceType)
-			cfg.AsteriscKona.Networks = nil
-			cfg.AsteriscKona.RollupConfigPaths = []string{"foo.json"}
+			cfg := validConfigWithNoNetworks(t, traceType)
 			cfg.AsteriscKona.L2GenesisPaths = nil
 			require.ErrorIs(t, cfg.Check(), vm.ErrMissingL2Genesis)
 		})

op-challenger/flags/flags.go

@@ -44,6 +44,11 @@ var (
 		Usage:   "Address of L1 Beacon API endpoint to use",
 		EnvVars: prefixEnvVars("L1_BEACON"),
 	}
+	L1GenesisFlag = &cli.StringFlag{
+		Name:    "l1-genesis-path",
+		Usage:   "Path to the L1 genesis file. Only required if the L1 is not mainnet, sepolia, holesky, or hoodi.",
+		EnvVars: prefixEnvVars("L1_GENESIS_PATH"),
+	}
 	SupervisorRpcFlag = &cli.StringFlag{
 		Name:    "supervisor-rpc",
 		Usage:   "Provider URL for supervisor RPC",
@@ -283,6 +288,7 @@ var optionalFlags = []cli.Flag{
 	GameWindowFlag,
 	SelectiveClaimResolutionFlag,
 	UnsafeAllowInvalidPrestate,
+	L1GenesisFlag,
 }
 
 func init() {
@@ -625,6 +631,7 @@ func NewConfigFromCLI(ctx *cli.Context, logger log.Logger) (*config.Config, erro
 		RollupRpc:               ctx.String(RollupRpcFlag.Name),
 		SupervisorRPC:           ctx.String(SupervisorRpcFlag.Name),
 		Cannon: vm.Config{
+			L1GenesisPath:     ctx.String(L1GenesisFlag.Name),
 			VmType:            types.TraceTypeCannon,
 			L1:                l1EthRpc,
 			L1Beacon:          l1Beacon,
@@ -646,6 +653,7 @@ func NewConfigFromCLI(ctx *cli.Context, logger log.Logger) (*config.Config, erro
 		CannonAbsolutePreStateBaseURL: cannonPreStatesURL,
 		Datadir:                       ctx.String(DatadirFlag.Name),
 		Asterisc: vm.Config{
+			L1GenesisPath:     ctx.String(L1GenesisFlag.Name),
 			VmType:            types.TraceTypeAsterisc,
 			L1:                l1EthRpc,
 			L1Beacon:          l1Beacon,
@@ -664,6 +672,7 @@ func NewConfigFromCLI(ctx *cli.Context, logger log.Logger) (*config.Config, erro
 		AsteriscAbsolutePreState:        ctx.String(AsteriscPreStateFlag.Name),
 		AsteriscAbsolutePreStateBaseURL: asteriscPreStatesURL,
 		AsteriscKona: vm.Config{
+			L1GenesisPath:     ctx.String(L1GenesisFlag.Name),
 			VmType:            types.TraceTypeAsteriscKona,
 			L1:                l1EthRpc,
 			L1Beacon:          l1Beacon,

op-challenger/game/fault/trace/vm/executor.go

@@ -57,6 +57,7 @@ type Config struct {
 	Networks          []string
 	L2Custom          bool
 	RollupConfigPaths []string
+	L1GenesisPath     string
 	L2GenesisPaths    []string
 	DepsetConfigPath  string
 }

op-challenger/game/fault/trace/vm/kona_server_executor.go

@@ -57,5 +57,9 @@ func (s *KonaExecutor) OracleCommand(cfg Config, dataDir string, inputs utils.Lo
 		args = append(args, "--l2-chain-id", strconv.FormatUint(chainCfg.ChainID, 10))
 	}
 
+	if cfg.L1GenesisPath != "" {
+		args = append(args, "--l1-config-path", cfg.L1GenesisPath)
+	}
+
 	return args, nil
 }

op-challenger/game/fault/trace/vm/kona_server_executor_test.go

@@ -13,11 +13,12 @@ import (
 func TestKonaFillHostCommand(t *testing.T) {
 	dir := "mockdir"
 	cfg := Config{
-		L1:       "http://localhost:8888",
-		L1Beacon: "http://localhost:9000",
-		L2s:      []string{"http://localhost:9999"},
-		Server:   "./bin/mockserver",
-		Networks: []string{"op-mainnet"},
+		L1:            "http://localhost:8888",
+		L1Beacon:      "http://localhost:9000",
+		L2s:           []string{"http://localhost:9999"},
+		Server:        "./bin/mockserver",
+		Networks:      []string{"op-mainnet"},
+		L1GenesisPath: "mockdir/l1-genesis-1.json",
 	}
 	inputs := utils.LocalGameInputs{
 		L1Head:           common.Hash{0x11},
@@ -43,4 +44,5 @@ func TestKonaFillHostCommand(t *testing.T) {
 	require.True(t, slices.Contains(args, "--l2-output-root"))
 	require.True(t, slices.Contains(args, "--l2-claim"))
 	require.True(t, slices.Contains(args, "--l2-block-number"))
+	require.True(t, slices.Contains(args, "--l1-config-path"))
 }

op-challenger/game/fault/trace/vm/kona_super_server_executor.go

@@ -50,5 +50,9 @@ func (s *KonaSuperExecutor) OracleCommand(cfg Config, dataDir string, inputs uti
 		args = append(args, "--rollup-config-paths", strings.Join(cfg.RollupConfigPaths, ","))
 	}
 
+	if cfg.L1GenesisPath != "" {
+		args = append(args, "--l1-config-path", cfg.L1GenesisPath)
+	}
+
 	return args, nil
 }

op-challenger/game/fault/trace/vm/op_program_server_executor.go

@@ -72,5 +72,8 @@ func (s *OpProgramServerExecutor) OracleCommand(cfg Config, dataDir string, inpu
 	if cfg.L2Custom {
 		args = append(args, "--l2.custom")
 	}
+	if cfg.L1GenesisPath != "" {
+		args = append(args, "--l1.config", cfg.L1GenesisPath)
+	}
 	return args, nil
 }

op-challenger/game/fault/trace/vm/op_program_server_executor_test.go

@@ -33,10 +33,11 @@ func TestOpProgramFillHostCommand(t *testing.T) {
 
 	oracleCommand := func(t *testing.T, lvl slog.Level, configModifier func(c *Config, inputs *utils.LocalGameInputs)) map[string]string {
 		cfg := Config{
-			L1:       "http://localhost:8888",
-			L1Beacon: "http://localhost:9000",
-			L2s:      []string{"http://localhost:9999", "http://localhost:9999/two"},
-			Server:   "./bin/mockserver",
+			L1:            "http://localhost:8888",
+			L1Beacon:      "http://localhost:9000",
+			L2s:           []string{"http://localhost:9999", "http://localhost:9999/two"},
+			Server:        "./bin/mockserver",
+			L1GenesisPath: "mockdir/l1-genesis-1.json",
 		}
 		inputs := utils.LocalGameInputs{
 			L1Head:           common.Hash{0x11},
@@ -60,6 +61,7 @@ func TestOpProgramFillHostCommand(t *testing.T) {
 		require.Equal(t, inputs.L1Head.Hex(), pairs["--l1.head"])
 		require.Equal(t, inputs.L2Claim.Hex(), pairs["--l2.claim"])
 		require.Equal(t, inputs.L2SequenceNumber.String(), pairs["--l2.blocknumber"])
+		require.Equal(t, cfg.L1GenesisPath, pairs["--l1.config"])
 		return pairs
 	}
 

op-devstack/shared/challenger/challenger.go

@@ -52,7 +52,7 @@ func WithPrivKey(key *ecdsa.PrivateKey) Option {
 	}
 }
 
-func applyCannonConfig(c *config.Config, rollupCfgs []*rollup.Config, l2Geneses []*core.Genesis, prestateVariant PrestateVariant) error {
+func applyCannonConfig(c *config.Config, rollupCfgs []*rollup.Config, l1Genesis *core.Genesis, l2Geneses []*core.Genesis, prestateVariant PrestateVariant) error {
 	root, err := findMonorepoRoot()
 	if err != nil {
 		return err
@@ -79,6 +79,17 @@ func applyCannonConfig(c *config.Config, rollupCfgs []*rollup.Config, l2Geneses
 		c.Cannon.L2GenesisPaths = append(c.Cannon.L2GenesisPaths, genesisFile)
 	}
 
+	l1GenesisBytes, err := json.Marshal(l1Genesis)
+	if err != nil {
+		return fmt.Errorf("marshall l1 genesis config: %w", err)
+	}
+	l1GenesisFile := filepath.Join(c.Datadir, fmt.Sprintf("l1-genesis-%v.json", l1Genesis.Config.ChainID))
+	err = os.WriteFile(l1GenesisFile, l1GenesisBytes, 0o644)
+	if err != nil {
+		return fmt.Errorf("write l1 genesis config: %w", err)
+	}
+	c.Cannon.L1GenesisPath = l1GenesisFile
+
 	for _, rollupCfg := range rollupCfgs {
 		rollupBytes, err := json.Marshal(rollupCfg)
 		if err != nil {
@@ -101,9 +112,9 @@ func WithFactoryAddress(addr common.Address) Option {
 	}
 }
 
-func WithCannonConfig(rollupCfgs []*rollup.Config, l2Geneses []*core.Genesis, prestateVariant PrestateVariant) Option {
+func WithCannonConfig(rollupCfgs []*rollup.Config, l1Genesis *core.Genesis, l2Geneses []*core.Genesis, prestateVariant PrestateVariant) Option {
 	return func(c *config.Config) error {
-		return applyCannonConfig(c, rollupCfgs, l2Geneses, prestateVariant)
+		return applyCannonConfig(c, rollupCfgs, l1Genesis, l2Geneses, prestateVariant)
 	}
 }
 

op-devstack/sysgo/l2_challenger.go

@@ -101,6 +101,12 @@ func WithL2ChallengerPostDeploy(orch *Orchestrator, challengerID stack.L2Challen
 		l2NetIDs = append(l2NetIDs, l2Net.id)
 	}
 
+	l1Net, ok := orch.l1Nets.Get(l1ELID.ChainID())
+	if !ok {
+		require.Fail("l1 network not found")
+	}
+	l1Genesis := l1Net.genesis
+
 	dir := p.TempDir()
 	var cfg *config.Config
 	// If interop is scheduled, or if we cannot do the pre-interop connection, then set up with supervisor
@@ -122,7 +128,7 @@ func WithL2ChallengerPostDeploy(orch *Orchestrator, challengerID stack.L2Challen
 			shared.WithFactoryAddress(disputeGameFactoryAddr),
 			shared.WithPrivKey(challengerSecret),
 			shared.WithDepset(cluster.DepSet()),
-			shared.WithCannonConfig(rollupCfgs, l2Geneses, prestateVariant),
+			shared.WithCannonConfig(rollupCfgs, l1Genesis, l2Geneses, prestateVariant),
 			shared.WithSuperCannonTraceType(),
 			shared.WithSuperPermissionedTraceType(),
 		)
@@ -146,7 +152,7 @@ func WithL2ChallengerPostDeploy(orch *Orchestrator, challengerID stack.L2Challen
 		cfg, err = shared.NewPreInteropChallengerConfig(dir, l1EL.userRPC, l1CL.beaconHTTPAddr, l2CL.userRPC, l2EL.userRPC,
 			shared.WithFactoryAddress(disputeGameFactoryAddr),
 			shared.WithPrivKey(challengerSecret),
-			shared.WithCannonConfig(rollupCfgs, l2Geneses, prestateVariant),
+			shared.WithCannonConfig(rollupCfgs, l1Genesis, l2Geneses, prestateVariant),
 			shared.WithCannonTraceType(),
 			shared.WithPermissionedTraceType(),
 			shared.WithFastGames(),

op-devstack/sysgo/test_sequencer.go

@@ -109,10 +109,14 @@ func WithTestSequencer(testSequencerID stack.TestSequencerID, l1CLID stack.L1CLN
 		l2SequencerID := seqtypes.SequencerID(fmt.Sprintf("test-seq-%s", l2CLID.ChainID()))
 		l1SequencerID := seqtypes.SequencerID(fmt.Sprintf("test-seq-%s", l1ELID.ChainID()))
 
+		l1Net, ok := orch.l1Nets.Get(l1ELID.ChainID())
+		require.True(ok, "l1 net required")
+
 		v := &config.Ensemble{
 			Builders: map[seqtypes.BuilderID]*config.BuilderEntry{
 				bid_L2: {
 					Standard: &standardbuilder.Config{
+						L1ChainConfig: l1Net.genesis.Config,
 						L1EL: endpoint.MustRPC{
 							Value: endpoint.HttpURL(l1EL.userRPC),
 						},

op-e2e/actions/altda/altda_test.go

@@ -92,7 +92,7 @@ func NewL2AltDA(t helpers.Testing, params ...AltDAParam) *L2AltDA {
 	storage := &altda.DAErrFaker{Client: altda.NewMockDAClient(log)}
 	daMgr := altda.NewAltDAWithStorage(log, altDACfg, storage, &altda.NoopMetrics{})
 
-	sequencer := helpers.NewL2Sequencer(t, log, l1F, miner.BlobStore(), daMgr, engCl, sd.RollupCfg, sd.DependencySet, 0)
+	sequencer := helpers.NewL2Sequencer(t, log, l1F, miner.BlobStore(), daMgr, engCl, sd.RollupCfg, sd.L1Cfg.Config, sd.DependencySet, 0)
 	miner.ActL1SetFeeRecipient(common.Address{'A'})
 	sequencer.ActL2PipelineFull(t)
 
@@ -150,7 +150,7 @@ func (a *L2AltDA) NewVerifier(t helpers.Testing) *helpers.L2Verifier {
 
 	daMgr := altda.NewAltDAWithStorage(a.log, a.altDACfg, a.storage, &altda.NoopMetrics{})
 
-	verifier := helpers.NewL2Verifier(t, a.log, l1F, a.miner.BlobStore(), daMgr, engCl, a.sd.RollupCfg, a.sd.DependencySet, &sync.Config{}, safedb.Disabled)
+	verifier := helpers.NewL2Verifier(t, a.log, l1F, a.miner.BlobStore(), daMgr, engCl, a.sd.RollupCfg, a.sd.L1Cfg.Config, a.sd.DependencySet, &sync.Config{}, safedb.Disabled)
 
 	return verifier
 }

op-e2e/actions/derivation/batch_queue_test.go

@@ -95,7 +95,7 @@ func TestDeriveChainFromNearL1Genesis(gt *testing.T) {
 	l2Cl, err := sources.NewEngineClient(seqEngine.RPCClient(), logger, nil, sources.EngineClientDefaultConfig(sd.RollupCfg))
 	require.NoError(gt, err)
 	verifier := helpers.NewL2Verifier(t, logger, miner.L1Client(t, sd.RollupCfg), miner.BlobStore(), altda.Disabled,
-		l2Cl, sd.RollupCfg, sd.DependencySet, &sync.Config{}, safedb.Disabled)
+		l2Cl, sd.RollupCfg, sd.L1Cfg.Config, sd.DependencySet, &sync.Config{}, safedb.Disabled)
 	verifier.ActL2PipelineFull(t) // Should not get stuck in a reset loop forever
 	require.EqualValues(gt, l2BlockNum, seqEngine.L2Chain().CurrentSafeBlock().Number.Uint64())
 	require.EqualValues(gt, l2BlockNum, seqEngine.L2Chain().CurrentFinalBlock().Number.Uint64())