Introduce fast dispute game type (ethereum-optimism#10715)

* Introduce fast dispute game type

Avoids the need to change configuration to support fast withdrawals via fault proofs.

* e2e: Wait for game to become resolvable.

* Update kontrol snapshots.

* e2e: Set correct game type for proposer.

* challenger: Fast games are alphabet vm, not cannon.

* Set fast game clock duration to 0.

* Update snapshots again

* Use game type consistently.

bedrock-devnet/devnet/__init__.py

@@ -132,8 +132,6 @@ def init_devnet_l1_deploy_config(paths, update_timestamp=False):
         deploy_config['l1GenesisBlockTimestamp'] = '{:#x}'.format(int(time.time()))
     if DEVNET_FPAC:
         deploy_config['useFaultProofs'] = True
-        deploy_config['faultGameMaxClockDuration'] = 10
-        deploy_config['faultGameWithdrawalDelay'] = 0
     if DEVNET_PLASMA:
         deploy_config['usePlasma'] = True
     if GENERIC_PLASMA:
@@ -269,7 +267,7 @@ def devnet_deploy(paths):
     # Must be done selectively because op-proposer throws if both are set.
     if DEVNET_FPAC:
         docker_env['DGF_ADDRESS'] = dispute_game_factory
-        docker_env['DG_TYPE'] = '0'
+        docker_env['DG_TYPE'] = '254'
         docker_env['PROPOSAL_INTERVAL'] = '10s'
     else:
         docker_env['L2OO_ADDRESS'] = l2_output_oracle

op-challenger/config/config.go

@@ -54,12 +54,13 @@ type TraceType string
 
 const (
 	TraceTypeAlphabet     TraceType = "alphabet"
+	TraceTypeFast         TraceType = "fast"
 	TraceTypeCannon       TraceType = "cannon"
 	TraceTypeAsterisc     TraceType = "asterisc"
 	TraceTypePermissioned TraceType = "permissioned"
 )
 
-var TraceTypes = []TraceType{TraceTypeAlphabet, TraceTypeCannon, TraceTypePermissioned, TraceTypeAsterisc}
+var TraceTypes = []TraceType{TraceTypeAlphabet, TraceTypeCannon, TraceTypePermissioned, TraceTypeAsterisc, TraceTypeFast}
 
 func (t TraceType) String() string {
 	return string(t)

op-challenger/config/config_test.go

@@ -398,7 +398,7 @@ func TestRequireConfigForMultipleTraceTypesForCannonAndAsterisc(t *testing.T) {
 	cfg := validConfig(TraceTypeCannon)
 	applyValidConfigForAsterisc(&cfg)
 
-	cfg.TraceTypes = []TraceType{TraceTypeCannon, TraceTypeAsterisc, TraceTypeAlphabet}
+	cfg.TraceTypes = []TraceType{TraceTypeCannon, TraceTypeAsterisc, TraceTypeAlphabet, TraceTypeFast}
 	// Set all required options and check its valid
 	cfg.RollupRpc = validRollupRpc
 	require.NoError(t, cfg.Check())

op-challenger/flags/flags.go

@@ -346,7 +346,7 @@ func CheckRequired(ctx *cli.Context, traceTypes []config.TraceType) error {
 			if err := CheckAsteriscFlags(ctx); err != nil {
 				return err
 			}
-		case config.TraceTypeAlphabet:
+		case config.TraceTypeAlphabet, config.TraceTypeFast:
 		default:
 			return fmt.Errorf("invalid trace type. must be one of %v", config.TraceTypes)
 		}

op-challenger/game/fault/register.go

@@ -88,15 +88,21 @@ func RegisterGameTypes(
 			return nil, fmt.Errorf("failed to register asterisc game type: %w", err)
 		}
 	}
+	if cfg.TraceTypeEnabled(config.TraceTypeFast) {
+		if err := registerAlphabet(faultTypes.FastGameType, registry, oracles, ctx, systemClock, l1Clock, logger, m, syncValidator, rollupClient, l2Client, txSender, gameFactory, caller, l1HeaderSource, selective, claimants); err != nil {
+			return nil, fmt.Errorf("failed to register fast game type: %w", err)
+		}
+	}
 	if cfg.TraceTypeEnabled(config.TraceTypeAlphabet) {
-		if err := registerAlphabet(registry, oracles, ctx, systemClock, l1Clock, logger, m, syncValidator, rollupClient, l2Client, txSender, gameFactory, caller, l1HeaderSource, selective, claimants); err != nil {
+		if err := registerAlphabet(faultTypes.AlphabetGameType, registry, oracles, ctx, systemClock, l1Clock, logger, m, syncValidator, rollupClient, l2Client, txSender, gameFactory, caller, l1HeaderSource, selective, claimants); err != nil {
 			return nil, fmt.Errorf("failed to register alphabet game type: %w", err)
 		}
 	}
 	return l2Client.Close, nil
 }
 
 func registerAlphabet(
+	gameType uint32,
 	registry Registry,
 	oracles OracleRegistry,
 	ctx context.Context,
@@ -148,16 +154,16 @@ func registerAlphabet(
 		startingValidator := NewPrestateValidator("output root", contract.GetStartingRootHash, prestateProvider)
 		return NewGamePlayer(ctx, systemClock, l1Clock, logger, m, dir, game.Proxy, txSender, contract, syncValidator, []Validator{prestateValidator, startingValidator}, creator, l1HeaderSource, selective, claimants)
 	}
-	err := registerOracle(ctx, m, oracles, gameFactory, caller, faultTypes.AlphabetGameType)
+	err := registerOracle(ctx, m, oracles, gameFactory, caller, gameType)
 	if err != nil {
 		return err
 	}
-	registry.RegisterGameType(faultTypes.AlphabetGameType, playerCreator)
+	registry.RegisterGameType(gameType, playerCreator)
 
 	contractCreator := func(game types.GameMetadata) (claims.BondContract, error) {
 		return contracts.NewFaultDisputeGameContract(ctx, m, game.Proxy, caller)
 	}
-	registry.RegisterBondContract(faultTypes.AlphabetGameType, contractCreator)
+	registry.RegisterBondContract(gameType, contractCreator)
 	return nil
 }
 

op-challenger/game/fault/types/types.go

@@ -22,6 +22,7 @@ const (
 	CannonGameType       uint32 = 0
 	PermissionedGameType uint32 = 1
 	AsteriscGameType     uint32 = 2
+	FastGameType         uint32 = 254
 	AlphabetGameType     uint32 = 255
 )
 

op-e2e/actions/l2_proposer_test.go

@@ -57,10 +57,14 @@ func RunProposerTest(gt *testing.T, deltaTimeOffset *hexutil.Uint64) {
 
 	var proposer *L2Proposer
 	if e2eutils.UseFPAC() {
+		optimismPortal2Contract, err := bindingspreview.NewOptimismPortal2(sd.DeploymentsL1.OptimismPortalProxy, miner.EthClient())
+		require.NoError(t, err)
+		respectedGameType, err := optimismPortal2Contract.RespectedGameType(&bind.CallOpts{})
+		require.NoError(t, err)
 		proposer = NewL2Proposer(t, log, &ProposerCfg{
 			DisputeGameFactoryAddr: &sd.DeploymentsL1.DisputeGameFactoryProxy,
 			ProposalInterval:       6 * time.Second,
-			DisputeGameType:        0,
+			DisputeGameType:        respectedGameType,
 			ProposerKey:            dp.Secrets.Proposer,
 			AllowNonFinalized:      true,
 		}, miner.EthClient(), rollupSeqCl)

op-e2e/actions/user.go

@@ -1,13 +1,18 @@
 package actions
 
 import (
+	"context"
 	"crypto/ecdsa"
 	"errors"
 	"fmt"
 	"math/big"
 	"math/rand"
 	"time"
 
+	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/contracts"
+	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/contracts/metrics"
+	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/wait"
+	"github.com/ethereum-optimism/optimism/op-service/sources/batching"
 	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
@@ -450,7 +455,7 @@ func (s *CrossLayerUser) getLatestWithdrawalParams(t Testing) (*withdrawals.Prov
 	return &params, nil
 }
 
-func (s *CrossLayerUser) getDisputeGame(t Testing, params withdrawals.ProvenWithdrawalParameters) (*legacybindings.FaultDisputeGame, error) {
+func (s *CrossLayerUser) getDisputeGame(t Testing, params withdrawals.ProvenWithdrawalParameters) (*legacybindings.FaultDisputeGame, common.Address, error) {
 	wd := crossdomain.Withdrawal{
 		Nonce:    params.Nonce,
 		Sender:   &params.Sender,
@@ -473,7 +478,7 @@ func (s *CrossLayerUser) getDisputeGame(t Testing, params withdrawals.ProvenWith
 	proxy, err := legacybindings.NewFaultDisputeGame(game.DisputeGameProxy, s.L1.env.EthCl)
 	require.Nil(t, err)
 
-	return proxy, nil
+	return proxy, game.DisputeGameProxy, nil
 }
 
 // ActCompleteWithdrawal creates a L1 proveWithdrawal tx for latest withdrawal.
@@ -562,13 +567,21 @@ func (s *CrossLayerUser) ResolveClaim(t Testing, l2TxHash common.Hash) common.Ha
 		return common.Hash{}
 	}
 
-	game, err := s.getDisputeGame(t, *params)
+	game, gameAddr, err := s.getDisputeGame(t, *params)
 	require.NoError(t, err)
 
-	expiry, err := game.MaxClockDuration(&bind.CallOpts{})
+	caller := batching.NewMultiCaller(s.L1.env.EthCl.Client(), batching.DefaultBatchSize)
+	gameContract, err := contracts.NewFaultDisputeGameContract(context.Background(), metrics.NoopContractMetrics, gameAddr, caller)
 	require.Nil(t, err)
 
-	time.Sleep(time.Duration(expiry) * time.Second)
+	timedCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+	defer cancel()
+	require.NoError(t, wait.For(timedCtx, time.Second, func() (bool, error) {
+		err := gameContract.CallResolveClaim(context.Background(), 0)
+		t.Logf("Could not resolve dispute game claim: %v", err)
+		return err == nil, nil
+	}))
+
 	resolveClaimTx, err := game.ResolveClaim(&s.L1.txOpts, common.Big0, common.Big0)
 	require.Nil(t, err)
 
@@ -592,7 +605,7 @@ func (s *CrossLayerUser) Resolve(t Testing, l2TxHash common.Hash) common.Hash {
 		return common.Hash{}
 	}
 
-	game, err := s.getDisputeGame(t, *params)
+	game, _, err := s.getDisputeGame(t, *params)
 	require.NoError(t, err)
 
 	resolveTx, err := game.Resolve(&s.L1.txOpts)

op-e2e/actions/user_test.go

@@ -6,6 +6,8 @@ import (
 	"testing"
 	"time"
 
+	bindingspreview "github.com/ethereum-optimism/optimism/op-node/bindings/preview"
+	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common/hexutil"
 	"github.com/ethereum/go-ethereum/core/types"
 	"github.com/ethereum/go-ethereum/log"
@@ -135,10 +137,14 @@ func runCrossLayerUserTest(gt *testing.T, test hardforkScheduledTest) {
 
 	var proposer *L2Proposer
 	if e2eutils.UseFPAC() {
+		optimismPortal2Contract, err := bindingspreview.NewOptimismPortal2(sd.DeploymentsL1.OptimismPortalProxy, miner.EthClient())
+		require.NoError(t, err)
+		respectedGameType, err := optimismPortal2Contract.RespectedGameType(&bind.CallOpts{})
+		require.NoError(t, err)
 		proposer = NewL2Proposer(t, log, &ProposerCfg{
 			DisputeGameFactoryAddr: &sd.DeploymentsL1.DisputeGameFactoryProxy,
 			ProposalInterval:       6 * time.Second,
-			DisputeGameType:        0,
+			DisputeGameType:        respectedGameType,
 			ProposerKey:            dp.Secrets.Proposer,
 			AllowNonFinalized:      true,
 		}, miner.EthClient(), seq.RollupClient())

op-e2e/e2eutils/challenger/helper.go

@@ -133,6 +133,12 @@ func WithAlphabet() Option {
 	}
 }
 
+func WithFastGames() Option {
+	return func(c *config.Config) {
+		c.TraceTypes = append(c.TraceTypes, config.TraceTypeFast)
+	}
+}
+
 func NewChallenger(t *testing.T, ctx context.Context, sys EndpointProvider, name string, options ...Option) *Helper {
 	log := testlog.Logger(t, log.LevelDebug).New("role", name)
 	log.Info("Creating challenger")

op-e2e/faultproofs/output_alphabet_test.go

@@ -303,7 +303,7 @@ func TestHighestActedL1BlockMetric(t *testing.T) {
 	t.Cleanup(sys.Close)
 
 	disputeGameFactory := disputegame.NewFactoryHelper(t, ctx, sys)
-	honestChallenger := disputeGameFactory.StartChallenger(ctx, "Honest", challenger.WithAlphabet(), challenger.WithPrivKey(sys.Cfg.Secrets.Alice))
+	honestChallenger := disputeGameFactory.StartChallenger(ctx, "Honest", challenger.WithAlphabet(), challenger.WithFastGames(), challenger.WithPrivKey(sys.Cfg.Secrets.Alice))
 
 	game1 := disputeGameFactory.StartOutputAlphabetGame(ctx, "sequencer", 1, common.Hash{0xaa})
 	sys.AdvanceTime(game1.MaxClockDuration(ctx))

op-e2e/setup.go

@@ -782,7 +782,7 @@ func (cfg SystemConfig) Start(t *testing.T, _opts ...SystemConfigOption) (*Syste
 			RollupRpc:         sys.RollupNodes["sequencer"].HTTPEndpoint(),
 			DGFAddress:        config.L1Deployments.DisputeGameFactoryProxy.Hex(),
 			ProposalInterval:  6 * time.Second,
-			DisputeGameType:   0,
+			DisputeGameType:   254, // Fast game type
 			PollInterval:      50 * time.Millisecond,
 			TxMgrConfig:       newTxMgrConfig(sys.EthInstances["l1"].WSEndpoint(), cfg.Secrets.Proposer),
 			AllowNonFinalized: cfg.NonFinalizedProposals,

op-e2e/system_tob_test.go

@@ -659,7 +659,7 @@ func TestMixedWithdrawalValidity(t *testing.T) {
 					// Start a challenger to resolve claims and games once the clock expires
 					factoryHelper := disputegame.NewFactoryHelper(t, ctx, sys)
 					factoryHelper.StartChallenger(ctx, "Challenger",
-						challenger.WithCannon(t, sys.RollupConfig, sys.L2GenesisCfg),
+						challenger.WithFastGames(),
 						challenger.WithPrivKey(sys.Cfg.Secrets.Mallory))
 				}
 				receipt, err = wait.ForReceiptOK(ctx, l1Client, tx.Hash())

op-e2e/withdrawal_helper.go

@@ -8,6 +8,8 @@ import (
 	"time"
 
 	"github.com/ethereum-optimism/optimism/op-chain-ops/crossdomain"
+	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/contracts"
+	"github.com/ethereum-optimism/optimism/op-challenger/game/fault/contracts/metrics"
 	legacybindings "github.com/ethereum-optimism/optimism/op-e2e/bindings"
 	"github.com/ethereum-optimism/optimism/op-e2e/config"
 	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils"
@@ -17,6 +19,7 @@ import (
 	bindingspreview "github.com/ethereum-optimism/optimism/op-node/bindings/preview"
 	"github.com/ethereum-optimism/optimism/op-node/withdrawals"
 	"github.com/ethereum-optimism/optimism/op-service/predeploys"
+	"github.com/ethereum-optimism/optimism/op-service/sources/batching"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
@@ -201,10 +204,18 @@ func FinalizeWithdrawal(t *testing.T, cfg SystemConfig, l1Client *ethclient.Clie
 		proxy, err := legacybindings.NewFaultDisputeGame(game.DisputeGameProxy, l1Client)
 		require.Nil(t, err)
 
-		expiry, err := proxy.MaxClockDuration(&bind.CallOpts{})
+		caller := batching.NewMultiCaller(l1Client.Client(), batching.DefaultBatchSize)
+		gameContract, err := contracts.NewFaultDisputeGameContract(context.Background(), metrics.NoopContractMetrics, game.DisputeGameProxy, caller)
 		require.Nil(t, err)
 
-		time.Sleep(time.Duration(expiry) * time.Second)
+		timedCtx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+		defer cancel()
+		require.NoError(t, wait.For(timedCtx, time.Second, func() (bool, error) {
+			err := gameContract.CallResolveClaim(context.Background(), 0)
+			t.Logf("Could not resolve dispute game claim: %v", err)
+			return err == nil, nil
+		}))
+
 		resolveClaimTx, err := proxy.ResolveClaim(opts, common.Big0, common.Big0)
 		require.Nil(t, err)
 

ops-bedrock/docker-compose.yml

@@ -178,7 +178,7 @@ services:
       # Note: this will need to be updated to point to a L1 consensus node when there is one in the devnet
       OP_CHALLENGER_L1_BEACON: "unset"
       OP_CHALLENGER_ROLLUP_RPC: http://op-node:8545
-      OP_CHALLENGER_TRACE_TYPE: cannon
+      OP_CHALLENGER_TRACE_TYPE: cannon,fast
       OP_CHALLENGER_GAME_FACTORY_ADDRESS: ${DGF_ADDRESS}
       # The devnet can't set the absolute prestate output root because the contracts are deployed in L1 genesis
       # before the L2 genesis is known.

packages/contracts-bedrock/deploy-config/devnetL1-template.json

@@ -63,7 +63,7 @@
   "preimageOracleChallengePeriod": 120,
   "proofMaturityDelaySeconds": 12,
   "disputeGameFinalityDelaySeconds": 6,
-  "respectedGameType": 0,
+  "respectedGameType": 254,
   "useFaultProofs": false,
   "usePlasma": false,
   "daCommitmentType": "KeccakCommitment",