op-program: Add aliases to flags for interop.

op-challenger/cmd/list_claims.go

@@ -82,7 +82,7 @@ func listClaims(ctx context.Context, game contracts.FaultDisputeGameContract, ve
 		return fmt.Errorf("failed to retrieve split depth: %w", err)
 	}
 	status := metadata.Status
-	l2StartBlockNum, l2BlockNum, err := game.GetBlockRange(ctx)
+	l2StartBlockNum, l2BlockNum, err := game.GetGameRange(ctx)
 	if err != nil {
 		return fmt.Errorf("failed to retrieve status: %w", err)
 	}

op-challenger/cmd/list_games.go

@@ -116,7 +116,7 @@ func listGames(ctx context.Context, caller *batching.MultiCaller, factory *contr
 				return
 			}
 			infos[currIndex].status = metadata.Status
-			infos[currIndex].l2BlockNum = metadata.L2BlockNum
+			infos[currIndex].l2BlockNum = metadata.L2SequenceNum
 			infos[currIndex].rootClaim = metadata.RootClaim
 			claimCount, err := gameContract.GetClaimCount(ctx)
 			if err != nil {

op-challenger/game/fault/contracts/faultdisputegame.go

@@ -178,10 +178,10 @@ func (f *FaultDisputeGameContractLatest) GetBalanceAndDelay(ctx context.Context,
 	return balance, delay, weth.Addr(), nil
 }
 
-// GetBlockRange returns the block numbers of the absolute pre-state block (typically genesis or the bedrock activation block)
+// GetGameRange returns the block numbers of the absolute pre-state block (typically genesis or the bedrock activation block)
 // and the post-state block (that the proposed output root is for).
-func (f *FaultDisputeGameContractLatest) GetBlockRange(ctx context.Context) (prestateBlock uint64, poststateBlock uint64, retErr error) {
-	defer f.metrics.StartContractRequest("GetBlockRange")()
+func (f *FaultDisputeGameContractLatest) GetGameRange(ctx context.Context) (prestateBlock uint64, poststateBlock uint64, retErr error) {
+	defer f.metrics.StartContractRequest("GetGameRange")()
 	results, err := f.multiCaller.Call(ctx, rpcblock.Latest,
 		f.contract.Call(methodStartingBlockNumber),
 		f.contract.Call(methodL2BlockNumber))
@@ -200,7 +200,7 @@ func (f *FaultDisputeGameContractLatest) GetBlockRange(ctx context.Context) (pre
 
 type GameMetadata struct {
 	L1Head                  common.Hash
-	L2BlockNum              uint64
+	L2SequenceNum           uint64
 	RootClaim               common.Hash
 	Status                  gameTypes.GameStatus
 	MaxClockDuration        uint64
@@ -238,7 +238,7 @@ func (f *FaultDisputeGameContractLatest) GetGameMetadata(ctx context.Context, bl
 	blockChallenger := results[6].GetAddress(0)
 	return GameMetadata{
 		L1Head:                  l1Head,
-		L2BlockNum:              l2BlockNumber,
+		L2SequenceNum:           l2BlockNumber,
 		RootClaim:               rootClaim,
 		Status:                  status,
 		MaxClockDuration:        duration,
@@ -637,7 +637,7 @@ func (f *FaultDisputeGameContractLatest) decodeClaim(result *batching.CallResult
 
 type FaultDisputeGameContract interface {
 	GetBalanceAndDelay(ctx context.Context, block rpcblock.Block) (*big.Int, time.Duration, common.Address, error)
-	GetBlockRange(ctx context.Context) (prestateBlock uint64, poststateBlock uint64, retErr error)
+	GetGameRange(ctx context.Context) (prestateBlock uint64, poststateBlock uint64, retErr error)
 	GetGameMetadata(ctx context.Context, block rpcblock.Block) (GameMetadata, error)
 	GetResolvedAt(ctx context.Context, block rpcblock.Block) (time.Time, error)
 	GetStartingRootHash(ctx context.Context) (common.Hash, error)

op-challenger/game/fault/contracts/faultdisputegame0180.go

@@ -46,7 +46,7 @@ func (f *FaultDisputeGameContract0180) GetGameMetadata(ctx context.Context, bloc
 	duration := results[4].GetUint64(0)
 	return GameMetadata{
 		L1Head:                  l1Head,
-		L2BlockNum:              l2BlockNumber,
+		L2SequenceNum:           l2BlockNumber,
 		RootClaim:               rootClaim,
 		Status:                  status,
 		MaxClockDuration:        duration,

op-challenger/game/fault/contracts/faultdisputegame080.go

@@ -53,7 +53,7 @@ func (f *FaultDisputeGameContract080) GetGameMetadata(ctx context.Context, block
 	duration := results[4].GetUint64(0)
 	return GameMetadata{
 		L1Head:                  l1Head,
-		L2BlockNum:              l2BlockNumber,
+		L2SequenceNum:           l2BlockNumber,
 		RootClaim:               rootClaim,
 		Status:                  status,
 		MaxClockDuration:        duration / 2,

op-challenger/game/fault/contracts/faultdisputegame_test.go

@@ -48,7 +48,7 @@ func (c contractVersion) Is(versions ...string) bool {
 }
 
 func (c contractVersion) String() string {
-	return fmt.Sprintf("%s (%s)", c.version, c.gameType)
+	return fmt.Sprintf("%s_%s", c.version, c.gameType)
 }
 
 func (c contractVersion) IsSuperCannon() bool {
@@ -109,7 +109,7 @@ var versions = []contractVersion{
 	{
 		version:  verSuperCannon,
 		gameType: faultTypes.SuperCannonGameType,
-		loadAbi:  snapshots.LoadFaultDisputeGameABI,
+		loadAbi:  snapshots.LoadSuperFaultDisputeGameABI,
 	},
 }
 
@@ -543,9 +543,14 @@ func TestGetBlockRange(t *testing.T) {
 			stubRpc, contract := setupFaultDisputeGameTest(t, version)
 			expectedStart := uint64(65)
 			expectedEnd := uint64(102)
-			stubRpc.SetResponse(fdgAddr, methodStartingBlockNumber, rpcblock.Latest, nil, []interface{}{new(big.Int).SetUint64(expectedStart)})
-			stubRpc.SetResponse(fdgAddr, methodL2BlockNumber, rpcblock.Latest, nil, []interface{}{new(big.Int).SetUint64(expectedEnd)})
-			start, end, err := contract.GetBlockRange(context.Background())
+			if version.IsSuperCannon() {
+				stubRpc.SetResponse(fdgAddr, methodStartingSequenceNumber, rpcblock.Latest, nil, []interface{}{new(big.Int).SetUint64(expectedStart)})
+				stubRpc.SetResponse(fdgAddr, methodL2SequenceNumber, rpcblock.Latest, nil, []interface{}{new(big.Int).SetUint64(expectedEnd)})
+			} else {
+				stubRpc.SetResponse(fdgAddr, methodStartingBlockNumber, rpcblock.Latest, nil, []interface{}{new(big.Int).SetUint64(expectedStart)})
+				stubRpc.SetResponse(fdgAddr, methodL2BlockNumber, rpcblock.Latest, nil, []interface{}{new(big.Int).SetUint64(expectedEnd)})
+			}
+			start, end, err := contract.GetGameRange(context.Background())
 			require.NoError(t, err)
 			require.Equal(t, expectedStart, start)
 			require.Equal(t, expectedEnd, end)
@@ -581,21 +586,25 @@ func TestGetGameMetadata(t *testing.T) {
 			expectedL2BlockNumberChallenger := common.Address{0xee}
 			block := rpcblock.ByNumber(889)
 			stubRpc.SetResponse(fdgAddr, methodL1Head, block, nil, []interface{}{expectedL1Head})
-			stubRpc.SetResponse(fdgAddr, methodL2BlockNumber, block, nil, []interface{}{new(big.Int).SetUint64(expectedL2BlockNumber)})
+			if version.IsSuperCannon() {
+				stubRpc.SetResponse(fdgAddr, methodL2SequenceNumber, block, nil, []interface{}{new(big.Int).SetUint64(expectedL2BlockNumber)})
+			} else {
+				stubRpc.SetResponse(fdgAddr, methodL2BlockNumber, block, nil, []interface{}{new(big.Int).SetUint64(expectedL2BlockNumber)})
+			}
 			stubRpc.SetResponse(fdgAddr, methodRootClaim, block, nil, []interface{}{expectedRootClaim})
 			stubRpc.SetResponse(fdgAddr, methodStatus, block, nil, []interface{}{expectedStatus})
 			supportsL2BlockNumChallenge := (version.version != vers080 && version.version != vers0180) && !version.IsSuperCannon()
 			if supportsL2BlockNumChallenge {
 				stubRpc.SetResponse(fdgAddr, methodMaxClockDuration, block, nil, []interface{}{expectedMaxClockDuration})
 				stubRpc.SetResponse(fdgAddr, methodL2BlockNumberChallenged, block, nil, []interface{}{expectedL2BlockNumberChallenged})
 				stubRpc.SetResponse(fdgAddr, methodL2BlockNumberChallenger, block, nil, []interface{}{expectedL2BlockNumberChallenger})
-			} else if expectedL2BlockNumberChallenged {
+			} else {
 				t.Skip("Can't have challenged L2 block number on this contract version")
 			}
 			actual, err := contract.GetGameMetadata(context.Background(), block)
 			expected := GameMetadata{
 				L1Head:                  expectedL1Head,
-				L2BlockNum:              expectedL2BlockNumber,
+				L2SequenceNum:           expectedL2BlockNumber,
 				RootClaim:               expectedRootClaim,
 				Status:                  expectedStatus,
 				MaxClockDuration:        expectedMaxClockDuration,

op-challenger/game/fault/contracts/superfaultdisputegame.go

@@ -14,12 +14,17 @@ import (
 	"github.com/ethereum/go-ethereum/common"
 )
 
+var (
+	methodL2SequenceNumber       = "l2SequenceNumber"
+	methodStartingSequenceNumber = "startingSequenceNumber"
+)
+
 type SuperFaultDisputeGameContractLatest struct {
 	FaultDisputeGameContractLatest
 }
 
 func NewSuperFaultDisputeGameContract(ctx context.Context, metrics metrics.ContractMetricer, addr common.Address, caller *batching.MultiCaller) (FaultDisputeGameContract, error) {
-	contractAbi := snapshots.LoadFaultDisputeGameABI()
+	contractAbi := snapshots.LoadSuperFaultDisputeGameABI()
 	return &SuperFaultDisputeGameContractLatest{
 		FaultDisputeGameContractLatest: FaultDisputeGameContractLatest{
 			metrics:     metrics,
@@ -34,7 +39,7 @@ func (f *SuperFaultDisputeGameContractLatest) GetGameMetadata(ctx context.Contex
 	defer f.metrics.StartContractRequest("GetGameMetadata")()
 	results, err := f.multiCaller.Call(ctx, block,
 		f.contract.Call(methodL1Head),
-		f.contract.Call(methodL2BlockNumber),
+		f.contract.Call(methodL2SequenceNumber),
 		f.contract.Call(methodRootClaim),
 		f.contract.Call(methodStatus),
 		f.contract.Call(methodMaxClockDuration),
@@ -46,7 +51,7 @@ func (f *SuperFaultDisputeGameContractLatest) GetGameMetadata(ctx context.Contex
 		return GameMetadata{}, fmt.Errorf("expected 5 results but got %v", len(results))
 	}
 	l1Head := results[0].GetHash(0)
-	l2BlockNumber := results[1].GetBigInt(0).Uint64()
+	l2Timestamp := results[1].GetBigInt(0).Uint64()
 	rootClaim := results[2].GetHash(0)
 	status, err := gameTypes.GameStatusFromUint8(results[3].GetUint8(0))
 	if err != nil {
@@ -55,7 +60,7 @@ func (f *SuperFaultDisputeGameContractLatest) GetGameMetadata(ctx context.Contex
 	duration := results[4].GetUint64(0)
 	return GameMetadata{
 		L1Head:           l1Head,
-		L2BlockNum:       l2BlockNumber,
+		L2SequenceNum:    l2Timestamp,
 		RootClaim:        rootClaim,
 		Status:           status,
 		MaxClockDuration: duration,
@@ -69,3 +74,22 @@ func (f *SuperFaultDisputeGameContractLatest) IsL2BlockNumberChallenged(ctx cont
 func (f *SuperFaultDisputeGameContractLatest) ChallengeL2BlockNumberTx(challenge *types.InvalidL2BlockNumberChallenge) (txmgr.TxCandidate, error) {
 	return txmgr.TxCandidate{}, ErrChallengeL2BlockNotSupported
 }
+
+// GetGameRange returns the timestamps of the absolute pre-state and the proposed super root
+func (f *SuperFaultDisputeGameContractLatest) GetGameRange(ctx context.Context) (prestateBlock uint64, poststateBlock uint64, retErr error) {
+	defer f.metrics.StartContractRequest("GetGameRange")()
+	results, err := f.multiCaller.Call(ctx, rpcblock.Latest,
+		f.contract.Call(methodStartingSequenceNumber),
+		f.contract.Call(methodL2SequenceNumber))
+	if err != nil {
+		retErr = fmt.Errorf("failed to retrieve game range: %w", err)
+		return
+	}
+	if len(results) != 2 {
+		retErr = fmt.Errorf("expected 2 results but got %v", len(results))
+		return
+	}
+	prestateBlock = results[0].GetBigInt(0).Uint64()
+	poststateBlock = results[1].GetBigInt(0).Uint64()
+	return
+}

op-challenger/game/fault/register_task.go

@@ -273,7 +273,7 @@ func (e *RegisterTask) Register(
 			return nil, fmt.Errorf("failed to load oracle for game %v: %w", game.Proxy, err)
 		}
 		oracles.RegisterOracle(oracle)
-		prestateBlock, poststateBlock, err := contract.GetBlockRange(ctx)
+		prestateBlock, poststateBlock, err := contract.GetGameRange(ctx)
 		if err != nil {
 			return nil, err
 		}

op-challenger/game/fault/trace/super/super_cannon.go

@@ -30,23 +30,23 @@ func NewSuperCannonTraceAccessor(
 	dir string,
 	l1Head eth.BlockID,
 	splitDepth types.Depth,
-	prestateBlock uint64,
-	poststateBlock uint64,
+	prestateTimestamp uint64,
+	poststateTimestamp uint64,
 ) (*trace.Accessor, error) {
 	rollupCfgs, err := NewRollupConfigs(cfg)
 	if err != nil {
 		return nil, fmt.Errorf("failed to load rollup configs: %w", err)
 	}
-	outputProvider := NewSuperTraceProvider(logger, rollupCfgs, prestateProvider, rootProvider, l1Head, splitDepth, prestateBlock, poststateBlock)
+	outputProvider := NewSuperTraceProvider(logger, rollupCfgs, prestateProvider, rootProvider, l1Head, splitDepth, prestateTimestamp, poststateTimestamp)
 	cannonCreator := func(ctx context.Context, localContext common.Hash, depth types.Depth, claimInfo ClaimInfo) (types.TraceProvider, error) {
 		logger := logger.New("agreedPrestate", claimInfo.AgreedPrestate, "claim", claimInfo.Claim, "localContext", localContext)
 		subdir := filepath.Join(dir, localContext.Hex())
 		localInputs := utils.LocalGameInputs{
-			L1Head:         l1Head.Hash,
-			L2OutputRoot:   crypto.Keccak256Hash(claimInfo.AgreedPrestate),
-			AgreedPreState: claimInfo.AgreedPrestate,
-			L2Claim:        claimInfo.Claim,
-			L2BlockNumber:  new(big.Int).SetUint64(poststateBlock),
+			L1Head:           l1Head.Hash,
+			L2OutputRoot:     crypto.Keccak256Hash(claimInfo.AgreedPrestate),
+			AgreedPreState:   claimInfo.AgreedPrestate,
+			L2Claim:          claimInfo.Claim,
+			L2SequenceNumber: new(big.Int).SetUint64(poststateTimestamp),
 		}
 		provider := cannon.NewTraceProvider(logger, m.ToTypedVmMetrics(cfg.VmType.String()), cfg, serverExecutor, prestateProvider, cannonPrestate, localInputs, subdir, depth)
 		return provider, nil

op-challenger/game/fault/trace/utils/local.go

@@ -10,12 +10,12 @@ import (
 )
 
 type LocalGameInputs struct {
-	L1Head         common.Hash
-	L2Head         common.Hash
-	L2OutputRoot   common.Hash
-	AgreedPreState []byte
-	L2Claim        common.Hash
-	L2BlockNumber  *big.Int
+	L1Head           common.Hash
+	L2Head           common.Hash
+	L2OutputRoot     common.Hash
+	AgreedPreState   []byte
+	L2Claim          common.Hash
+	L2SequenceNumber *big.Int
 }
 
 type L2HeaderSource interface {
@@ -57,10 +57,10 @@ func FetchLocalInputsFromProposals(ctx context.Context, l1Head common.Hash, l2Cl
 	l2Head := agreedHeader.Hash()
 
 	return LocalGameInputs{
-		L1Head:        l1Head,
-		L2Head:        l2Head,
-		L2OutputRoot:  agreedOutput.OutputRoot,
-		L2Claim:       claimedOutput.OutputRoot,
-		L2BlockNumber: claimedOutput.L2BlockNumber,
+		L1Head:           l1Head,
+		L2Head:           l2Head,
+		L2OutputRoot:     agreedOutput.OutputRoot,
+		L2Claim:          claimedOutput.OutputRoot,
+		L2SequenceNumber: claimedOutput.L2BlockNumber,
 	}, nil
 }

op-challenger/game/fault/trace/utils/local_test.go

@@ -38,7 +38,7 @@ func TestFetchLocalInputs(t *testing.T) {
 	require.Equal(t, l2Client.header.Hash(), inputs.L2Head)
 	require.EqualValues(t, contract.starting.OutputRoot, inputs.L2OutputRoot)
 	require.EqualValues(t, contract.disputed.OutputRoot, inputs.L2Claim)
-	require.Equal(t, contract.disputed.L2BlockNumber, inputs.L2BlockNumber)
+	require.Equal(t, contract.disputed.L2BlockNumber, inputs.L2SequenceNumber)
 }
 
 func TestFetchLocalInputsFromProposals(t *testing.T) {
@@ -66,7 +66,7 @@ func TestFetchLocalInputsFromProposals(t *testing.T) {
 	require.Equal(t, l2Client.header.Hash(), inputs.L2Head)
 	require.EqualValues(t, agreed.OutputRoot, inputs.L2OutputRoot)
 	require.EqualValues(t, claimed.OutputRoot, inputs.L2Claim)
-	require.Equal(t, claimed.L2BlockNumber, inputs.L2BlockNumber)
+	require.Equal(t, claimed.L2BlockNumber, inputs.L2SequenceNumber)
 }
 
 type mockGameInputsSource struct {

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

@@ -39,11 +39,11 @@ func TestGenerateProof(t *testing.T) {
 	}
 
 	inputs := utils.LocalGameInputs{
-		L1Head:        common.Hash{0x11},
-		L2Head:        common.Hash{0x22},
-		L2OutputRoot:  common.Hash{0x33},
-		L2Claim:       common.Hash{0x44},
-		L2BlockNumber: big.NewInt(3333),
+		L1Head:           common.Hash{0x11},
+		L2Head:           common.Hash{0x22},
+		L2OutputRoot:     common.Hash{0x33},
+		L2Claim:          common.Hash{0x44},
+		L2SequenceNumber: big.NewInt(3333),
 	}
 
 	info := &mipsevm.DebugInfo{

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

@@ -36,7 +36,7 @@ func (s *KonaExecutor) OracleCommand(cfg Config, dataDir string, inputs utils.Lo
 		"--l2-head", inputs.L2Head.Hex(),
 		"--l2-output-root", inputs.L2OutputRoot.Hex(),
 		"--l2-claim", inputs.L2Claim.Hex(),
-		"--l2-block-number", inputs.L2BlockNumber.Text(10),
+		"--l2-block-number", inputs.L2SequenceNumber.Text(10),
 	}
 
 	if s.nativeMode {

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

@@ -20,11 +20,11 @@ func TestKonaFillHostCommand(t *testing.T) {
 		Networks: []string{"op-mainnet"},
 	}
 	inputs := utils.LocalGameInputs{
-		L1Head:        common.Hash{0x11},
-		L2Head:        common.Hash{0x22},
-		L2OutputRoot:  common.Hash{0x33},
-		L2Claim:       common.Hash{0x44},
-		L2BlockNumber: big.NewInt(3333),
+		L1Head:           common.Hash{0x11},
+		L2Head:           common.Hash{0x22},
+		L2OutputRoot:     common.Hash{0x33},
+		L2Claim:          common.Hash{0x44},
+		L2SequenceNumber: big.NewInt(3333),
 	}
 	vmConfig := NewKonaExecutor()
 

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

@@ -36,7 +36,7 @@ func (s *KonaSuperExecutor) OracleCommand(cfg Config, dataDir string, inputs uti
 		"--l1-head", inputs.L1Head.Hex(),
 		"--agreed-l2-pre-state", common.Bytes2Hex(inputs.AgreedPreState),
 		"--claimed-l2-post-state", inputs.L2Claim.Hex(),
-		"--claimed-l2-timestamp", inputs.L2BlockNumber.Text(10),
+		"--claimed-l2-timestamp", inputs.L2SequenceNumber.Text(10),
 	}
 
 	if s.nativeMode {

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

@@ -28,7 +28,7 @@ func (s *OpProgramServerExecutor) OracleCommand(cfg Config, dataDir string, inpu
 		"--datadir", dataDir,
 		"--l1.head", inputs.L1Head.Hex(),
 		"--l2.claim", inputs.L2Claim.Hex(),
-		"--l2.blocknumber", inputs.L2BlockNumber.Text(10),
+		"--l2.blocknumber", inputs.L2SequenceNumber.Text(10),
 	}
 	if inputs.L2Head != (common.Hash{}) {
 		args = append(args, "--l2.head", inputs.L2Head.Hex())

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

@@ -39,11 +39,11 @@ func TestOpProgramFillHostCommand(t *testing.T) {
 			Server:   "./bin/mockserver",
 		}
 		inputs := utils.LocalGameInputs{
-			L1Head:        common.Hash{0x11},
-			L2Head:        common.Hash{0x22},
-			L2OutputRoot:  common.Hash{0x33},
-			L2Claim:       common.Hash{0x44},
-			L2BlockNumber: big.NewInt(3333),
+			L1Head:           common.Hash{0x11},
+			L2Head:           common.Hash{0x22},
+			L2OutputRoot:     common.Hash{0x33},
+			L2Claim:          common.Hash{0x44},
+			L2SequenceNumber: big.NewInt(3333),
 		}
 		configModifier(&cfg, &inputs)
 		executor := NewOpProgramServerExecutor(testlog.Logger(t, lvl))
@@ -59,7 +59,7 @@ func TestOpProgramFillHostCommand(t *testing.T) {
 		require.Equal(t, dir, pairs["--datadir"])
 		require.Equal(t, inputs.L1Head.Hex(), pairs["--l1.head"])
 		require.Equal(t, inputs.L2Claim.Hex(), pairs["--l2.claim"])
-		require.Equal(t, inputs.L2BlockNumber.String(), pairs["--l2.blocknumber"])
+		require.Equal(t, inputs.L2SequenceNumber.String(), pairs["--l2.blocknumber"])
 		return pairs
 	}