Merge pull request #6221 from ethereum-optimism/refcell/step-func

feat(op-challenger): Responder Step Function

op-challenger/fault/orchestrator.go

@@ -34,6 +34,10 @@ func (o *Orchestrator) Respond(_ context.Context, response Claim) error {
 	return nil
 }
 
+func (o *Orchestrator) Step(ctx context.Context, stepData StepCallData) error {
+	return nil
+}
+
 func (o *Orchestrator) Start() {
 	for i := 0; i < len(o.agents); i++ {
 		go runAgent(&o.agents[i], o.outputChs[i])

op-challenger/fault/responder.go

@@ -74,17 +74,19 @@ func (r *faultResponder) BuildTx(ctx context.Context, response Claim) ([]byte, e
 
 // Respond takes a [Claim] and executes the response action.
 func (r *faultResponder) Respond(ctx context.Context, response Claim) error {
-	// Build the transaction data.
 	txData, err := r.BuildTx(ctx, response)
 	if err != nil {
 		return err
 	}
+	return r.sendTxAndWait(ctx, txData)
+}
 
-	// Send the transaction through the [txmgr].
+// sendTxAndWait sends a transaction through the [txmgr] and waits for a receipt.
+// This sets the tx GasLimit to 0, performing gas estimation online through the [txmgr].
+func (r *faultResponder) sendTxAndWait(ctx context.Context, txData []byte) error {
 	receipt, err := r.txMgr.Send(ctx, txmgr.TxCandidate{
-		To:     &r.fdgAddr,
-		TxData: txData,
-		// Setting GasLimit to 0 performs gas estimation online through the [txmgr].
+		To:       &r.fdgAddr,
+		TxData:   txData,
 		GasLimit: 0,
 	})
 	if err != nil {
@@ -95,6 +97,26 @@ func (r *faultResponder) Respond(ctx context.Context, response Claim) error {
 	} else {
 		r.log.Info("responder tx successfully published", "tx_hash", receipt.TxHash)
 	}
-
 	return nil
 }
+
+// buildStepTxData creates the transaction data for the step function.
+func (r *faultResponder) buildStepTxData(stepData StepCallData) ([]byte, error) {
+	return r.fdgAbi.Pack(
+		"step",
+		big.NewInt(int64(stepData.StateIndex)),
+		big.NewInt(int64(stepData.ClaimIndex)),
+		stepData.IsAttack,
+		stepData.StateData,
+		stepData.Proof,
+	)
+}
+
+// Step accepts step data and executes the step on the fault dispute game contract.
+func (r *faultResponder) Step(ctx context.Context, stepData StepCallData) error {
+	txData, err := r.buildStepTxData(stepData)
+	if err != nil {
+		return err
+	}
+	return r.sendTxAndWait(ctx, txData)
+}

op-challenger/fault/types.go

@@ -12,6 +12,15 @@ var (
 	ErrIndexTooLarge = errors.New("index is larger than the maximum index")
 )
 
+// StepCallData encapsulates the data needed to perform a step.
+type StepCallData struct {
+	StateIndex uint64
+	ClaimIndex uint64
+	IsAttack   bool
+	StateData  []byte
+	Proof      []byte
+}
+
 // TraceProvider is a generic way to get a claim value at a specific
 // step in the trace.
 // The [AlphabetProvider] is a minimal implementation of this interface.
@@ -60,4 +69,5 @@ func (c *Claim) DefendsParent() bool {
 // For full op-challenger this means executing the transaction on chain.
 type Responder interface {
 	Respond(ctx context.Context, response Claim) error
+	Step(ctx context.Context, stepData StepCallData) error
 }