Merge branch 'develop' into jg/txmgr_harden

op-e2e/e2eutils/disputegame/helper.go

@@ -11,7 +11,9 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
 	"github.com/ethereum-optimism/optimism/op-chain-ops/deployer"
 	"github.com/ethereum-optimism/optimism/op-chain-ops/genesis"
+	"github.com/ethereum-optimism/optimism/op-challenger/config"
 	"github.com/ethereum-optimism/optimism/op-challenger/fault/alphabet"
+	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/challenger"
 	"github.com/ethereum-optimism/optimism/op-e2e/e2eutils/wait"
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
@@ -52,6 +54,7 @@ type FactoryHelper struct {
 	require     *require.Assertions
 	client      *ethclient.Client
 	opts        *bind.TransactOpts
+	factoryAddr common.Address
 	factory     *bindings.DisputeGameFactory
 	blockOracle *bindings.BlockOracle
 	l2oo        *bindings.L2OutputOracleCaller
@@ -65,7 +68,8 @@ func NewFactoryHelper(t *testing.T, ctx context.Context, deployments *genesis.L1
 	require.NoError(err)
 
 	require.NotNil(deployments, "No deployments")
-	factory, err := bindings.NewDisputeGameFactory(deployments.DisputeGameFactoryProxy, client)
+	factoryAddr := deployments.DisputeGameFactoryProxy
+	factory, err := bindings.NewDisputeGameFactory(factoryAddr, client)
 	require.NoError(err)
 	blockOracle, err := bindings.NewBlockOracle(deployments.BlockOracle, client)
 	require.NoError(err)
@@ -78,6 +82,7 @@ func NewFactoryHelper(t *testing.T, ctx context.Context, deployments *genesis.L1
 		client:      client,
 		opts:        opts,
 		factory:     factory,
+		factoryAddr: factoryAddr,
 		blockOracle: blockOracle,
 		l2oo:        l2oo,
 	}
@@ -150,6 +155,21 @@ func (h *FactoryHelper) StartCannonGame(ctx context.Context, rootClaim common.Ha
 		},
 	}
 }
+func (h *FactoryHelper) StartChallenger(ctx context.Context, l1Endpoint string, name string, options ...challenger.Option) *challenger.Helper {
+	opts := []challenger.Option{
+		func(c *config.Config) {
+			// Uncomment when challenger actually supports setting the game factory address
+			//c.FactoryAddress = h.factoryAddr
+			c.TraceType = config.TraceTypeAlphabet
+		},
+	}
+	opts = append(opts, options...)
+	c := challenger.NewChallenger(h.t, ctx, l1Endpoint, name, opts...)
+	h.t.Cleanup(func() {
+		_ = c.Close()
+	})
+	return c
+}
 
 // waitForProposals waits until there are at least two proposals in the output oracle
 // This is the minimum required for creating a game.

op-e2e/faultproof_test.go

@@ -13,6 +13,37 @@ import (
 	"github.com/stretchr/testify/require"
 )
 
+func TestCannonMultipleGames(t *testing.T) {
+	t.Skip("Challenger doesn't yet support multiple games")
+	InitParallel(t)
+
+	ctx := context.Background()
+	sys, l1Client := startFaultDisputeSystem(t)
+	t.Cleanup(sys.Close)
+
+	gameFactory := disputegame.NewFactoryHelper(t, ctx, sys.cfg.L1Deployments, l1Client)
+	// Start a challenger with the correct alphabet trace
+	gameFactory.StartChallenger(ctx, sys.NodeEndpoint("l1"), "TowerDefense", func(c *config.Config) {
+		c.AgreeWithProposedOutput = true
+		c.AlphabetTrace = "abcdefg"
+		c.TxMgrConfig.PrivateKey = e2eutils.EncodePrivKeyToString(sys.cfg.Secrets.Alice)
+	})
+
+	game1 := gameFactory.StartAlphabetGame(ctx, "abcxyz")
+	// Wait for the challenger to respond to the first game
+	game1.WaitForClaimCount(ctx, 2)
+
+	game2 := gameFactory.StartAlphabetGame(ctx, "zyxabc")
+	// Wait for the challenger to respond to the second game
+	game2.WaitForClaimCount(ctx, 2)
+
+	// Challenger should respond to new claims
+	game2.Attack(ctx, 1, common.Hash{0xaa})
+	game2.WaitForClaimCount(ctx, 4)
+	game1.Defend(ctx, 1, common.Hash{0xaa})
+	game1.WaitForClaimCount(ctx, 4)
+}
+
 func TestResolveDisputeGame(t *testing.T) {
 	InitParallel(t)
 

op-service/backoff/operation.go

@@ -17,6 +17,10 @@ func (e *ErrFailedPermanently) Error() string {
 	return fmt.Sprintf("operation failed permanently after %d attempts: %v", e.attempts, e.LastErr)
 }
 
+func (e *ErrFailedPermanently) Unwrap() error {
+	return e.LastErr
+}
+
 type pair[T, U any] struct {
 	a T
 	b U
@@ -35,37 +39,27 @@ func Do2[T, U any](ctx context.Context, maxAttempts int, strategy Strategy, op f
 // with delays in between each retry according to the provided
 // Strategy.
 func Do[T any](ctx context.Context, maxAttempts int, strategy Strategy, op func() (T, error)) (T, error) {
-	var empty T
+	var empty, ret T
+	var err error
 	if maxAttempts < 1 {
 		return empty, fmt.Errorf("need at least 1 attempt to run op, but have %d max attempts", maxAttempts)
 	}
-	var attempt int
 
-	reattemptCh := make(chan struct{}, 1)
-	doReattempt := func() {
-		reattemptCh <- struct{}{}
-	}
-	doReattempt()
-
-	for {
-		select {
-		case <-ctx.Done():
+	for i := 0; i < maxAttempts; i++ {
+		if ctx.Err() != nil {
 			return empty, ctx.Err()
-		case <-reattemptCh:
-			attempt++
-			ret, err := op()
-			if err == nil {
-				return ret, nil
-			}
-
-			if attempt == maxAttempts {
-				return empty, &ErrFailedPermanently{
-					attempts: maxAttempts,
-					LastErr:  err,
-				}
-			}
-			time.AfterFunc(strategy.Duration(attempt-1), doReattempt)
 		}
-
+		ret, err = op()
+		if err == nil {
+			return ret, nil
+		}
+		// Don't sleep when we are about to exit the loop & return ErrFailedPermanently
+		if i != maxAttempts-1 {
+			time.Sleep(strategy.Duration(i))
+		}
+	}
+	return empty, &ErrFailedPermanently{
+		attempts: maxAttempts,
+		LastErr:  err,
 	}
 }