sysgo: add Osaka activation test

Author: joshklop

mise.toml

@@ -15,6 +15,7 @@ svm-rs = "0.5.19"
 
 # Go dependencies
 "go:github.com/ethereum/go-ethereum/cmd/abigen" = "1.15.10"
+"go:github.com/ethereum/go-ethereum/cmd/geth" = "ad55a3e07fe3854aa6582cca612f2fdf09915f67" # Commit contains Osaka functionality.
 "go:gotest.tools/gotestsum" = "1.12.1"
 "go:github.com/vektra/mockery/v2" = "2.46.0"
 "go:github.com/golangci/golangci-lint/cmd/golangci-lint" = "1.64.8"

op-acceptance-tests/tests/osaka/activation_test.go

@@ -0,0 +1,73 @@
+package osaka
+
+import (
+	"bytes"
+	"fmt"
+	"os"
+	"os/exec"
+	"strings"
+	"testing"
+	"time"
+
+	"github.com/ethereum-optimism/optimism/op-batcher/batcher"
+	"github.com/ethereum-optimism/optimism/op-batcher/flags"
+	"github.com/ethereum-optimism/optimism/op-chain-ops/devkeys"
+	"github.com/ethereum-optimism/optimism/op-devstack/devtest"
+	"github.com/ethereum-optimism/optimism/op-devstack/presets"
+	"github.com/ethereum-optimism/optimism/op-devstack/stack"
+	"github.com/ethereum-optimism/optimism/op-devstack/sysgo"
+	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/intentbuilder"
+	"github.com/ethereum-optimism/optimism/op-service/eth"
+)
+
+const osakaOffset = 30
+
+func TestMain(m *testing.M) {
+	// If the env var is unset, use geth (should be installed with mise).
+	// Note that we always want a subprocess L1 EL for these tests because (as of right now) the
+	// op-geth version we use in the monorepo does not include enough Osaka support.
+	if _, ok := os.LookupEnv(sysgo.GethExecPathEnvVar); !ok {
+		cmd := exec.Command("mise", "which", "geth")
+		buf := bytes.NewBuffer([]byte{})
+		cmd.Stdout = buf
+		if err := cmd.Run(); err == nil {
+			execPath := strings.TrimSpace(buf.String())
+			fmt.Println("Found mise-installed geth:", execPath)
+			_ = os.Setenv(sysgo.GethExecPathEnvVar, execPath)
+			defer func() {
+				_ = os.Setenv(sysgo.GethExecPathEnvVar, "")
+			}()
+		} else {
+			fmt.Printf("Failed to find mise-installed geth: %v\n", err)
+		}
+	}
+
+	ids := sysgo.NewDefaultMinimalSystemIDs(sysgo.DefaultL1ID, sysgo.DefaultL2AID)
+	opt := stack.Combine[*sysgo.Orchestrator]()
+	opt.Add(sysgo.DefaultMinimalSystem(&ids))
+	opt.Add(sysgo.WithDeployerOptions(
+		func(_ devtest.P, _ devkeys.Keys, builder intentbuilder.Builder) {
+			_, l1Config := builder.WithL1(ids.L1.ChainID())
+			l1Config.WithOsakaOffset(osakaOffset)
+		}))
+	opt.Add(sysgo.WithBatcherOption(func(_ stack.L2BatcherID, cfg *batcher.CLIConfig) {
+		cfg.DataAvailabilityType = flags.BlobsType
+	}))
+	presets.DoMain(m, stack.MakeCommon(opt))
+}
+
+func TestOsakaActivation(gt *testing.T) {
+	t := devtest.SerialT(gt)
+	sys := presets.NewMinimal(t)
+	osakaActivationTime := *sys.L1Network.Escape().ChainConfig().OsakaTime
+	t.Log("Waiting for Osaka to activate...")
+	for range time.Tick(sys.L1EL.EstimateBlockTime()) {
+		ref := sys.L1EL.BlockRefByLabel(eth.Unsafe)
+		if ref.Time >= osakaActivationTime {
+			break
+		}
+		t.Logf("Waiting for Osaka activation currentBlock=%d remainingTime=%d", ref.Number, osakaActivationTime-ref.Time)
+	}
+	t.Log("Osaka activated")
+	sys.L1EL.WaitForFinalization()
+}

op-chain-ops/genesis/config.go

@@ -377,6 +377,8 @@ type UpgradeScheduleDeployConfig struct {
 	L1CancunTimeOffset *hexutil.Uint64 `json:"l1CancunTimeOffset,omitempty"`
 	// When Prague activates. Relative to L1 genesis.
 	L1PragueTimeOffset *hexutil.Uint64 `json:"l1PragueTimeOffset,omitempty"`
+	// When Osaka activates. Relative to L1 genesis.
+	L1OsakaTimeOffset *hexutil.Uint64 `json:"l1OsakaTimeOffset,omitempty"`
 }
 
 var _ ConfigChecker = (*UpgradeScheduleDeployConfig)(nil)

op-chain-ops/genesis/genesis.go

@@ -139,6 +139,7 @@ func NewL1Genesis(config *DeployConfig) (*core.Genesis, error) {
 		DevL1DeployConfig:  config.DevL1DeployConfig,
 		L1ChainID:          eth.ChainIDFromUInt64(config.L1ChainID),
 		L1PragueTimeOffset: (*uint64)(config.L1PragueTimeOffset),
+		L1OsakaTimeOffset:  (*uint64)(config.L1OsakaTimeOffset),
 	})
 }
 
@@ -148,6 +149,8 @@ type DevL1DeployConfigMinimal struct {
 	L1ChainID eth.ChainID
 	// When Prague activates. Relative to L1 genesis.
 	L1PragueTimeOffset *uint64
+	// When Osaka activates. Relative to L1 genesis.
+	L1OsakaTimeOffset *uint64
 }
 
 // NewL1GenesisMinimal creates a L1 dev genesis template.
@@ -203,6 +206,10 @@ func NewL1GenesisMinimal(config *DevL1DeployConfigMinimal) (*core.Genesis, error
 		pragueTime := uint64(timestamp) + uint64(*config.L1PragueTimeOffset)
 		chainConfig.PragueTime = &pragueTime
 	}
+	if config.L1OsakaTimeOffset != nil {
+		osakaTime := uint64(timestamp) + uint64(*config.L1OsakaTimeOffset)
+		chainConfig.OsakaTime = &osakaTime
+	}
 	// Note: excess-blob-gas, blob-gas-used, withdrawals-hash, requests-hash are set to reasonable defaults for L1 by the ToBlock() function
 	return &core.Genesis{
 		Config:        &chainConfig,

op-deployer/pkg/deployer/pipeline/seal_l1_dev_genesis.go

@@ -48,6 +48,7 @@ func SealL1DevGenesis(env *Env, intent *state.Intent, st *state.State) error {
 		},
 		L1ChainID:          eth.ChainIDFromUInt64(intent.L1ChainID),
 		L1PragueTimeOffset: l1DevParams.PragueTimeOffset,
+		L1OsakaTimeOffset:  l1DevParams.OsakaTimeOffset,
 	})
 	if err != nil {
 		return fmt.Errorf("failed to create dev L1 genesis template: %w", err)

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

@@ -55,6 +55,10 @@ type L1DevGenesisParams struct {
 	// PragueTimeOffset configures Prague (aka Pectra) to be activated at the given time after L1 dev genesis time.
 	PragueTimeOffset *uint64 `json:"pragueTimeOffset" toml:"pragueTimeOffset"`
 
+	// OsakaTimeOffset configures Osaka (the EL changes in the Fusaka Ethereum fork) to be
+	// activated at the given time after L1 dev genesis time.
+	OsakaTimeOffset *uint64 `json:"osakaTimeOffset" toml:"osakaTimeOffset"`
+
 	// Prefund is a map of addresses to balances (in wei), to prefund in the L1 dev genesis state.
 	// This is independent of the "Prefund" functionality that may fund a default 20 test accounts.
 	Prefund map[common.Address]*hexutil.U256 `json:"prefund" toml:"prefund"`

op-devstack/sysgo/engine_client.go

@@ -64,6 +64,10 @@ func (e *engineClient) GetPayloadV4(id engine.PayloadID) (*engine.ExecutionPaylo
 	return e.getPayload(id, "engine_getPayloadV4")
 }
 
+func (e *engineClient) GetPayloadV5(id engine.PayloadID) (*engine.ExecutionPayloadEnvelope, error) {
+	return e.getPayload(id, "engine_getPayloadV5")
+}
+
 func (e *engineClient) NewPayloadV2(data engine.ExecutableData) (engine.PayloadStatusV1, error) {
 	var result engine.PayloadStatusV1
 	if err := e.inner.CallContext(context.Background(), &result, "engine_newPayloadV2", data); err != nil {

op-e2e/e2eutils/geth/fakepos.go

@@ -59,6 +59,7 @@ type EngineAPI interface {
 	ForkchoiceUpdatedV3(engine.ForkchoiceStateV1, *engine.PayloadAttributes) (engine.ForkChoiceResponse, error)
 	ForkchoiceUpdatedV2(engine.ForkchoiceStateV1, *engine.PayloadAttributes) (engine.ForkChoiceResponse, error)
 
+	GetPayloadV5(engine.PayloadID) (*engine.ExecutionPayloadEnvelope, error)
 	GetPayloadV4(engine.PayloadID) (*engine.ExecutionPayloadEnvelope, error)
 	GetPayloadV3(engine.PayloadID) (*engine.ExecutionPayloadEnvelope, error)
 	GetPayloadV2(engine.PayloadID) (*engine.ExecutionPayloadEnvelope, error)
@@ -157,8 +158,10 @@ func (f *FakePoS) Start() error {
 					Withdrawals:           withdrawals,
 				}
 				parentBeaconBlockRoot := f.FakeBeaconBlockRoot(head.Time) // parent beacon block root
-				isCancun := f.config.IsCancun(new(big.Int).SetUint64(head.Number.Uint64()+1), newBlockTime)
-				isPrague := f.config.IsPrague(new(big.Int).SetUint64(head.Number.Uint64()+1), newBlockTime)
+				nextHeight := new(big.Int).SetUint64(head.Number.Uint64() + 1)
+				isCancun := f.config.IsCancun(nextHeight, newBlockTime)
+				isPrague := f.config.IsPrague(nextHeight, newBlockTime)
+				isOsaka := f.config.IsOsaka(nextHeight, newBlockTime)
 				if isCancun {
 					attrs.BeaconRoot = &parentBeaconBlockRoot
 				}
@@ -192,7 +195,9 @@ func (f *FakePoS) Start() error {
 					return nil
 				}
 				var envelope *engine.ExecutionPayloadEnvelope
-				if isPrague {
+				if isOsaka {
+					envelope, err = f.engineAPI.GetPayloadV5(*res.PayloadID)
+				} else if isPrague {
 					envelope, err = f.engineAPI.GetPayloadV4(*res.PayloadID)
 				} else if isCancun {
 					envelope, err = f.engineAPI.GetPayloadV3(*res.PayloadID)

op-e2e/e2eutils/intentbuilder/builder.go

@@ -28,6 +28,7 @@ type L1Configurator interface {
 	WithGasLimit(v uint64) L1Configurator
 	WithExcessBlobGas(v uint64) L1Configurator
 	WithPragueOffset(v uint64) L1Configurator
+	WithOsakaOffset(v uint64) L1Configurator
 	WithPrefundedAccount(addr common.Address, amount uint256.Int) L1Configurator
 }
 
@@ -303,6 +304,12 @@ func (c *l1Configurator) WithPragueOffset(v uint64) L1Configurator {
 	return c
 }
 
+func (c *l1Configurator) WithOsakaOffset(v uint64) L1Configurator {
+	c.initL1DevGenesisParams()
+	c.builder.intent.L1DevGenesisParams.OsakaTimeOffset = &v
+	return c
+}
+
 func (c *l1Configurator) WithPrefundedAccount(addr common.Address, amount uint256.Int) L1Configurator {
 	c.initL1DevGenesisParams()
 	c.builder.intent.L1DevGenesisParams.Prefund[addr] = (*hexutil.U256)(&amount)

op-e2e/e2eutils/intentbuilder/builder_test.go

@@ -36,6 +36,7 @@ func TestBuilder(t *testing.T) {
 
 	// Configure L1
 	pragueOffset := uint64(100)
+	osakaOffset := uint64(200)
 	alice := common.HexToAddress("0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa")
 	aliceFunds := uint256.NewInt(10000)
 	l1Params := state.L1DevGenesisParams{
@@ -45,6 +46,7 @@ func TestBuilder(t *testing.T) {
 			ExcessBlobGas: 123,
 		},
 		PragueTimeOffset: &pragueOffset,
+		OsakaTimeOffset:  &osakaOffset,
 		Prefund: map[common.Address]*hexutil.U256{
 			alice: (*hexutil.U256)(aliceFunds),
 		},
@@ -55,6 +57,7 @@ func TestBuilder(t *testing.T) {
 	l1Config.WithGasLimit(l1Params.BlockParams.GasLimit)
 	l1Config.WithExcessBlobGas(l1Params.BlockParams.ExcessBlobGas)
 	l1Config.WithPragueOffset(*l1Params.PragueTimeOffset)
+	l1Config.WithOsakaOffset(*l1Params.OsakaTimeOffset)
 	l1Config.WithPrefundedAccount(alice, *aliceFunds)
 
 	// Configure L2