Add the resolve call to the responder using the txmgr

Co-authored-by: Adrian Sutton <adrian@oplabs.co>

op-challenger/fault/responder.go

@@ -7,6 +7,7 @@ import (
 	"github.com/ethereum-optimism/optimism/op-bindings/bindings"
 	"github.com/ethereum-optimism/optimism/op-service/txmgr"
 
+	"github.com/ethereum/go-ethereum"
 	"github.com/ethereum/go-ethereum/accounts/abi"
 	"github.com/ethereum/go-ethereum/common"
 	"github.com/ethereum/go-ethereum/core/types"
@@ -77,6 +78,20 @@ func (r *faultResponder) BuildTx(ctx context.Context, response Claim) ([]byte, e
 	}
 }
 
+// CanResolve determines if the resolve function on the fault dispute game contract
+// would succeed. Returns true if the game can be resolved, otherwise false.
+func (r *faultResponder) CanResolve(ctx context.Context) bool {
+	txData, err := r.buildResolveData()
+	if err != nil {
+		return false
+	}
+	_, err = r.txMgr.Call(ctx, ethereum.CallMsg{
+		To:   &r.fdgAddr,
+		Data: txData,
+	}, nil)
+	return err == nil
+}
+
 // Resolve executes a resolve transaction to resolve a fault dispute game.
 func (r *faultResponder) Resolve(ctx context.Context) error {
 	txData, err := r.buildResolveData()

op-challenger/fault/responder_test.go

@@ -26,6 +26,7 @@ var (
 type mockTxManager struct {
 	from      common.Address
 	sends     int
+	calls     int
 	sendFails bool
 }
 
@@ -42,7 +43,11 @@ func (m *mockTxManager) Send(ctx context.Context, candidate txmgr.TxCandidate) (
 }
 
 func (m *mockTxManager) Call(_ context.Context, _ ethereum.CallMsg, _ *big.Int) ([]byte, error) {
-	panic("unimplemented")
+	if m.sendFails {
+		return nil, mockSendError
+	}
+	m.calls++
+	return []byte{}, nil
 }
 
 func (m *mockTxManager) BlockNumber(ctx context.Context) (uint64, error) {
@@ -62,6 +67,24 @@ func newTestFaultResponder(t *testing.T, sendFails bool) (*faultResponder, *mock
 	return responder, mockTxMgr
 }
 
+// TestResponder_CanResolve_CallFails tests the [Responder.CanResolve] method
+// bubbles up the error returned by the [txmgr.Call] method.
+func TestResponder_CanResolve_CallFails(t *testing.T) {
+	responder, mockTxMgr := newTestFaultResponder(t, true)
+	resolved := responder.CanResolve(context.Background())
+	require.False(t, resolved)
+	require.Equal(t, 0, mockTxMgr.sends)
+}
+
+// TestResponder_CanResolve_Success tests the [Responder.CanResolve] method
+// succeeds when the call message is successfully sent through the txmgr.
+func TestResponder_CanResolve_Success(t *testing.T) {
+	responder, mockTxMgr := newTestFaultResponder(t, false)
+	resolved := responder.CanResolve(context.Background())
+	require.True(t, resolved)
+	require.Equal(t, 1, mockTxMgr.calls)
+}
+
 // TestResponder_Resolve_SendFails tests the [Responder.Resolve] method
 // bubbles up the error returned by the [txmgr.Send] method.
 func TestResponder_Resolve_SendFails(t *testing.T) {