Add test for devnet challenge game

Author: jbearer

espresso/.env

@@ -34,6 +34,9 @@ OPERATOR_PRIVATE_KEY=0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf
 # cast wallet address --private-key $OPERATOR_PRIVATE_KEY
 OPERATOR_ADDRESS=0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266
 
+# cast wallet address --mnemonic "test test ... junk" --hd-path "m/44'/60'/0'/0/1"
+PROPOSER_ADDRESS=0x70997970C51812dc3A010C7d01b50e0d17dc79C8
+
 L1_CHAIN_ID=11155111
 L2_CHAIN_ID=22266222
 

espresso/devnet-tests/batcher_restart_test.go

@@ -13,7 +13,7 @@ func TestBatcherRestart(t *testing.T) {
 	defer cancel()
 
 	d := NewDevnet(ctx, t)
-	require.NoError(t, d.Up(testing.Verbose()))
+	require.NoError(t, d.Up())
 	defer func() {
 		require.NoError(t, d.Down())
 	}()

espresso/devnet-tests/challenge_test.go

@@ -0,0 +1,49 @@
+package devnet_tests
+
+import (
+	"context"
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/require"
+)
+
+func TestChallengeGame(t *testing.T) {
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+
+	d := NewDevnet(ctx, t)
+	require.NoError(t, d.Up())
+	defer func() {
+		require.NoError(t, d.Down())
+	}()
+
+	// Wait for the proposer to make a claim.
+	var games []ChallengeGame
+	for len(games) == 0 {
+		var err error
+		t.Logf("waiting for a challenge game")
+		time.Sleep(5 * time.Second)
+		games, err = d.ListChallengeGames()
+		require.NoError(t, err)
+	}
+	t.Logf("game created: %v", games[0])
+	require.Equal(t, uint64(1), games[0].Claims)
+
+	// Attack the first claimed state.
+	t.Logf("attacking game")
+	require.NoError(t, d.OpChallenger("move", "--attack", "--game-address", games[0].Address.Hex()))
+
+	// Check that the proposer correctly responds.
+	for {
+		updatedGames, err := d.ListChallengeGames()
+		require.NoError(t, err)
+		if updatedGames[0].Claims == 3 {
+			require.Equal(t, updatedGames[0].OutputRoot, games[0].OutputRoot)
+			break
+		}
+
+		t.Logf("waiting for a response")
+		time.Sleep(time.Second)
+	}
+}

espresso/devnet-tests/devnet_tools.go

@@ -5,6 +5,7 @@ import (
 	"context"
 	"encoding/hex"
 	"fmt"
+	"io"
 	"math/big"
 	"os"
 	"os/exec"
@@ -73,7 +74,7 @@ func NewDevnet(ctx context.Context, t *testing.T) *Devnet {
 	return d
 }
 
-func (d *Devnet) Up(verbose bool) (err error) {
+func (d *Devnet) Up() (err error) {
 	cmd := exec.CommandContext(
 		d.ctx,
 		"docker", "compose", "up", "-d",
@@ -107,7 +108,7 @@ func (d *Devnet) Up(verbose bool) (err error) {
 		}
 	}()
 
-	if verbose {
+	if testing.Verbose() {
 		// Stream logs to stdout while the test runs. This goroutine will automatically exit when
 		// the context is cancelled.
 		go func() {
@@ -376,6 +377,158 @@ func (d *Devnet) Down() error {
 	return cmd.Run()
 }
 
+type TaggedWriter struct {
+	inner   io.Writer
+	tag     string
+	newline bool
+}
+
+func NewTaggedWriter(tag string, inner io.Writer) *TaggedWriter {
+	return &TaggedWriter{
+		inner:   inner,
+		tag:     tag,
+		newline: true,
+	}
+}
+
+func (w *TaggedWriter) Write(p []byte) (int, error) {
+	if w.newline {
+		if _, err := fmt.Fprintf(w.inner, "%s | ", w.tag); err != nil {
+			return 0, err
+		}
+		w.newline = false
+	}
+
+	written := 0
+	for i := range len(p) {
+		// Buffer bytes until we hit a newline.
+		if p[i] == '\n' {
+			// Print everything we've buffered up to and including the newline.
+			line := p[written : i+1]
+			n, err := w.inner.Write(line)
+			written += n
+			if err != nil || n < len(line) {
+				return written, err
+			}
+
+			// If that's the end of the output, return, but make a note that the buffer ended with a
+			// newline and we need to print the tag before the next message.
+			if written == len(p) {
+				w.newline = true
+				return written, nil
+			}
+
+			// Otherwise print the tag now before proceeding with the next line in `p`.
+			if _, err := fmt.Fprintf(w.inner, "%s | ", w.tag); err != nil {
+				return written, err
+			}
+		}
+	}
+
+	// Print anything that was buffered after the final newline.
+	if written < len(p) {
+		line := p[written:]
+		n, err := w.inner.Write(line)
+		written += n
+		if err != nil || n < len(line) {
+			return written, err
+		}
+	}
+
+	return written, nil
+}
+
+func (d *Devnet) OpChallenger(opts ...string) error {
+	return d.opChallengerCmd(opts...).Run()
+}
+
+type ChallengeGame struct {
+	Index      uint64
+	Address    common.Address
+	OutputRoot []byte
+	Claims     uint64
+}
+
+func ParseChallengeGame(s string) (ChallengeGame, error) {
+	fields := strings.Fields(s)
+	if len(fields) < 8 {
+		return ChallengeGame{}, fmt.Errorf("challenge game is missing fields; expected at least 8 but got only %v", len(fields))
+	}
+
+	index, err := strconv.ParseUint(fields[0], 10, 64)
+	if err != nil {
+		return ChallengeGame{}, fmt.Errorf("index invalid: %w", err)
+	}
+
+	address := common.HexToAddress(fields[1])
+
+	outputRoot := common.Hex2Bytes(fields[6])
+
+	claims, err := strconv.ParseUint(fields[7], 10, 64)
+	if err != nil {
+		return ChallengeGame{}, fmt.Errorf("claims count invalid: %w", err)
+	}
+
+	return ChallengeGame{
+		Index:      index,
+		Address:    address,
+		OutputRoot: outputRoot,
+		Claims:     claims,
+	}, nil
+}
+
+func (d *Devnet) ListChallengeGames() ([]ChallengeGame, error) {
+	output, err := d.OpChallengerOutput("list-games")
+	if err != nil {
+		return nil, err
+	}
+
+	var games []ChallengeGame
+	for i, line := range strings.Split(output, "\n") {
+		if i == 0 {
+			// Ignore header.
+			continue
+		}
+		line = strings.TrimSpace(line)
+		if len(line) == 0 {
+			// Ignore empty lines (e.g. trailing newline)
+			continue
+		}
+
+		game, err := ParseChallengeGame(line)
+		if err != nil {
+			return nil, fmt.Errorf("game %v is invalid: %w", i, err)
+		}
+		games = append(games, game)
+	}
+	return games, nil
+}
+
+func (d *Devnet) OpChallengerOutput(opts ...string) (string, error) {
+	cmd := d.opChallengerCmd(opts...)
+	buf := new(bytes.Buffer)
+	cmd.Stdout = buf
+	if err := cmd.Run(); err != nil {
+		return "", err
+	}
+	return buf.String(), nil
+}
+
+func (d *Devnet) opChallengerCmd(opts ...string) *exec.Cmd {
+	opts = append([]string{"compose", "exec", "op-challenger", "entrypoint.sh", "op-challenger"}, opts...)
+	cmd := exec.CommandContext(
+		d.ctx,
+		"docker",
+		opts...,
+	)
+	if testing.Verbose() {
+		cmd.Stdout = NewTaggedWriter("op-challenger-cmd", os.Stdout)
+		cmd.Stderr = NewTaggedWriter("op-challenger-cmd", os.Stderr)
+	}
+	log.Info("invoking op-challenger", "cmd", cmd)
+	return cmd
+}
+
 // Get the host port mapped to `privatePort` for the given Docker service.
 func (d *Devnet) hostPort(service string, privatePort uint16) (uint16, error) {
 	buf := new(bytes.Buffer)

espresso/devnet-tests/key_rotation_test.go

@@ -19,7 +19,7 @@ func TestRotateBatcherKey(t *testing.T) {
 	// We're going to change batcher key to Bob's, verify that it won't be a no-op
 	require.NotEqual(t, d.secrets.Batcher, d.secrets.Bob)
 
-	require.NoError(t, d.Up(testing.Verbose()))
+	require.NoError(t, d.Up())
 	defer func() {
 		require.NoError(t, d.Down())
 	}()
@@ -57,7 +57,7 @@ func TestChangeBatchInboxOwner(t *testing.T) {
 
 	d := NewDevnet(ctx, t)
 
-	require.NoError(t, d.Up(testing.Verbose()))
+	require.NoError(t, d.Up())
 	defer func() {
 		require.NoError(t, d.Down())
 	}()