clarify

Author: julienrbrt

execution/evm/execution.go

@@ -74,7 +74,7 @@ func validatePayloadStatus(status engine.PayloadStatusV1) error {
 //   - Fails immediately on ErrInvalidPayloadStatus (permanent failures)
 //   - Respects context cancellation for graceful shutdown
 //   - Uses exponential backoff that doubles on each attempt
-func retryWithBackoff(ctx context.Context, fn func() error, maxRetries int, initialBackoff time.Duration, operation string) error {
+func retryWithBackoffOnPayloadStatus(ctx context.Context, fn func() error, maxRetries int, initialBackoff time.Duration, operation string) error {
 	backoff := initialBackoff
 
 	for attempt := 1; attempt <= maxRetries; attempt++ {
@@ -186,7 +186,7 @@ func (c *EngineClient) InitChain(ctx context.Context, genesisTime time.Time, ini
 	}
 
 	// Acknowledge the genesis block with retry logic for SYNCING status
-	err := retryWithBackoff(ctx, func() error {
+	err := retryWithBackoffOnPayloadStatus(ctx, func() error {
 		var forkchoiceResult engine.ForkChoiceResponse
 		err := c.engineClient.CallContext(ctx, &forkchoiceResult, "engine_forkchoiceUpdatedV3",
 			engine.ForkchoiceStateV1{
@@ -291,7 +291,7 @@ func (c *EngineClient) ExecuteTxs(ctx context.Context, txs [][]byte, blockHeight
 
 	// Call forkchoice update with retry logic for SYNCING status
 	var payloadID *engine.PayloadID
-	err = retryWithBackoff(ctx, func() error {
+	err = retryWithBackoffOnPayloadStatus(ctx, func() error {
 		var forkchoiceResult engine.ForkChoiceResponse
 		err := c.engineClient.CallContext(ctx, &forkchoiceResult, "engine_forkchoiceUpdatedV3", args, evPayloadAttrs)
 		if err != nil {
@@ -340,7 +340,7 @@ func (c *EngineClient) ExecuteTxs(ctx context.Context, txs [][]byte, blockHeight
 
 	// Submit payload with retry logic for SYNCING status
 	var newPayloadResult engine.PayloadStatusV1
-	err = retryWithBackoff(ctx, func() error {
+	err = retryWithBackoffOnPayloadStatus(ctx, func() error {
 		err := c.engineClient.CallContext(ctx, &newPayloadResult, "engine_newPayloadV4",
 			payloadResult.ExecutionPayload,
 			[]string{},          // No blob hashes
@@ -396,7 +396,7 @@ func (c *EngineClient) setFinal(ctx context.Context, blockHash common.Hash, isFi
 	c.mu.Unlock()
 
 	// Call forkchoice update with retry logic for SYNCING status
-	err := retryWithBackoff(ctx, func() error {
+	err := retryWithBackoffOnPayloadStatus(ctx, func() error {
 		var forkchoiceResult engine.ForkChoiceResponse
 		err := c.engineClient.CallContext(ctx, &forkchoiceResult, "engine_forkchoiceUpdatedV3", args, nil)
 		if err != nil {

execution/evm/execution_status_test.go

@@ -77,8 +77,8 @@ func TestValidatePayloadStatus(t *testing.T) {
 	}
 }
 
-// TestRetryWithBackoff tests the retry logic with exponential backoff
-func TestRetryWithBackoff(t *testing.T) {
+// TestRetryWithBackoffOnPayloadStatus tests the retry logic with exponential backoff
+func TestRetryWithBackoffOnPayloadStatus(t *testing.T) {
 	t.Parallel()
 
 	tests := []struct {
@@ -157,7 +157,7 @@ func TestRetryWithBackoff(t *testing.T) {
 			}
 
 			ctx := context.Background()
-			err := retryWithBackoff(ctx, retryFn, tt.maxRetries, 1*time.Millisecond, "test_operation")
+			err := retryWithBackoffOnPayloadStatus(ctx, retryFn, tt.maxRetries, 1*time.Millisecond, "test_operation")
 
 			if tt.shouldSucceed {
 				require.NoError(t, err, "expected success but got error")
@@ -170,8 +170,8 @@ func TestRetryWithBackoff(t *testing.T) {
 	}
 }
 
-// TestRetryWithBackoff_ContextCancellation tests that retry respects context cancellation
-func TestRetryWithBackoff_ContextCancellation(t *testing.T) {
+// TestRetryWithBackoffOnPayloadStatus_ContextCancellation tests that retry respects context cancellation
+func TestRetryWithBackoffOnPayloadStatus_ContextCancellation(t *testing.T) {
 	t.Parallel()
 
 	attempts := 0
@@ -183,16 +183,16 @@ func TestRetryWithBackoff_ContextCancellation(t *testing.T) {
 	ctx, cancel := context.WithCancel(context.Background())
 	cancel() // Cancel immediately
 
-	err := retryWithBackoff(ctx, retryFn, 5, 100*time.Millisecond, "test_operation")
+	err := retryWithBackoffOnPayloadStatus(ctx, retryFn, 5, 100*time.Millisecond, "test_operation")
 
 	require.Error(t, err, "expected error due to context cancellation")
 	assert.ErrorIs(t, err, context.Canceled, "expected context.Canceled error")
 	// Should fail fast on context cancellation without retries
 	assert.LessOrEqual(t, attempts, 1, "expected at most 1 attempt, got %d", attempts)
 }
 
-// TestRetryWithBackoff_ContextTimeout tests that retry respects context timeout
-func TestRetryWithBackoff_ContextTimeout(t *testing.T) {
+// TestRetryWithBackoffOnPayloadStatus_ContextTimeout tests that retry respects context timeout
+func TestRetryWithBackoffOnPayloadStatus_ContextTimeout(t *testing.T) {
 	t.Parallel()
 
 	attempts := 0
@@ -205,16 +205,16 @@ func TestRetryWithBackoff_ContextTimeout(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
 	defer cancel()
 
-	err := retryWithBackoff(ctx, retryFn, 10, 1*time.Second, "test_operation")
+	err := retryWithBackoffOnPayloadStatus(ctx, retryFn, 10, 1*time.Second, "test_operation")
 
 	require.Error(t, err, "expected error due to context timeout")
 	assert.ErrorIs(t, err, context.DeadlineExceeded, "expected context.DeadlineExceeded error")
 	// Should stop on timeout, not exhaust all retries
 	assert.Less(t, attempts, 10, "expected fewer than 10 attempts due to timeout, got %d", attempts)
 }
 
-// TestRetryWithBackoff_RPCErrors tests that RPC errors are not retried
-func TestRetryWithBackoff_RPCErrors(t *testing.T) {
+// TestRetryWithBackoffOnPayloadStatus_RPCErrors tests that RPC errors are not retried
+func TestRetryWithBackoffOnPayloadStatus_RPCErrors(t *testing.T) {
 	t.Parallel()
 
 	rpcError := errors.New("RPC connection failed")
@@ -225,16 +225,16 @@ func TestRetryWithBackoff_RPCErrors(t *testing.T) {
 	}
 
 	ctx := context.Background()
-	err := retryWithBackoff(ctx, retryFn, 5, 1*time.Millisecond, "test_operation")
+	err := retryWithBackoffOnPayloadStatus(ctx, retryFn, 5, 1*time.Millisecond, "test_operation")
 
 	require.Error(t, err, "expected error from RPC failure")
 	assert.Equal(t, rpcError, err, "expected original RPC error to be returned")
 	// Should fail immediately without retries on non-syncing errors
 	assert.Equal(t, 1, attempts, "expected exactly 1 attempt, got %d", attempts)
 }
 
-// TestRetryWithBackoff_WrappedRPCErrors tests that wrapped RPC errors are not retried
-func TestRetryWithBackoff_WrappedRPCErrors(t *testing.T) {
+// TestRetryWithBackoffOnPayloadStatus_WrappedRPCErrors tests that wrapped RPC errors are not retried
+func TestRetryWithBackoffOnPayloadStatus_WrappedRPCErrors(t *testing.T) {
 	t.Parallel()
 
 	rpcError := errors.New("connection refused")
@@ -245,7 +245,7 @@ func TestRetryWithBackoff_WrappedRPCErrors(t *testing.T) {
 	}
 
 	ctx := context.Background()
-	err := retryWithBackoff(ctx, retryFn, 5, 1*time.Millisecond, "test_operation")
+	err := retryWithBackoffOnPayloadStatus(ctx, retryFn, 5, 1*time.Millisecond, "test_operation")
 
 	require.Error(t, err, "expected error from RPC failure")
 	// Should fail immediately without retries on non-syncing errors