Merge branch 'develop' into calculate-post-state

beacon-chain/core/transition/transition_no_verify_sig.go

@@ -116,17 +116,32 @@ func CalculateStateRoot(
 	rollback state.BeaconState,
 	signed interfaces.ReadOnlySignedBeaconBlock,
 ) ([32]byte, error) {
-	ctx, span := trace.StartSpan(ctx, "core.state.CalculateStateRoot")
+	st, err := CalculatePostState(ctx, rollback, signed)
+	if err != nil {
+		return [32]byte{}, err
+	}
+	return st.HashTreeRoot(ctx)
+}
+
+// CalculatePostState returns the post-block state after processing the given
+// block on a copy of the input state. It is identical to CalculateStateRoot
+// but returns the full state instead of just its hash tree root.
+func CalculatePostState(
+	ctx context.Context,
+	rollback state.BeaconState,
+	signed interfaces.ReadOnlySignedBeaconBlock,
+) (state.BeaconState, error) {
+	ctx, span := trace.StartSpan(ctx, "core.state.CalculatePostState")
 	defer span.End()
 	if ctx.Err() != nil {
 		tracing.AnnotateError(span, ctx.Err())
-		return [32]byte{}, ctx.Err()
+		return nil, ctx.Err()
 	}
 	if rollback == nil || rollback.IsNil() {
-		return [32]byte{}, errors.New("nil state")
+		return nil, errors.New("nil state")
 	}
 	if signed == nil || signed.IsNil() || signed.Block().IsNil() {
-		return [32]byte{}, errors.New("nil block")
+		return nil, errors.New("nil block")
 	}
 
 	// Copy state to avoid mutating the state reference.
@@ -137,22 +152,22 @@ func CalculateStateRoot(
 	parentRoot := signed.Block().ParentRoot()
 	state, err = ProcessSlotsUsingNextSlotCache(ctx, state, parentRoot[:], signed.Block().Slot())
 	if err != nil {
-		return [32]byte{}, errors.Wrap(err, "could not process slots")
+		return nil, errors.Wrap(err, "could not process slots")
 	}
 
 	// Execute per block transition.
 	if features.Get().EnableProposerPreprocessing {
 		state, err = processBlockForProposing(ctx, state, signed)
 		if err != nil {
-			return [32]byte{}, errors.Wrap(err, "could not process block for proposing")
+			return nil, errors.Wrap(err, "could not process block for proposing")
 		}
 	} else {
 		state, err = ProcessBlockForStateRoot(ctx, state, signed)
 		if err != nil {
-			return [32]byte{}, errors.Wrap(err, "could not process block")
+			return nil, errors.Wrap(err, "could not process block")
 		}
 	}
-	return state.HashTreeRoot(ctx)
+	return state, nil
 }
 
 // processBlockVerifySigs processes the block and verifies the signatures within it. Block signatures are not verified as this block is not yet signed.

beacon-chain/rpc/prysm/v1alpha1/validator/proposer.go

@@ -609,21 +609,31 @@ func (vs *Server) GetFeeRecipientByPubKey(ctx context.Context, request *ethpb.Fe
 // computeStateRoot computes the state root after a block has been processed through a state transition and
 // returns it to the validator client.
 func (vs *Server) computeStateRoot(ctx context.Context, block interfaces.SignedBeaconBlock) ([]byte, error) {
+	st, err := vs.computePostBlockState(ctx, block)
+	if err != nil {
+		return nil, err
+	}
+	root, err := st.HashTreeRoot(ctx)
+	if err != nil {
+		return nil, errors.Wrap(err, "could not compute state root")
+	}
+	log.WithField("beaconStateRoot", fmt.Sprintf("%#x", root)).Debugf("Computed state root")
+	return root[:], nil
+}
+
+// computePostBlockState computes the post-block state by running the state transition.
+// It uses the same logic as CalculateStateRoot (Copy, feature flags, slot processing)
+// but returns the full state instead of just its hash.
+func (vs *Server) computePostBlockState(ctx context.Context, block interfaces.SignedBeaconBlock) (state.BeaconState, error) {
 	beaconState, err := vs.StateGen.StateByRoot(ctx, block.Block().ParentRoot())
 	if err != nil {
 		return nil, errors.Wrap(err, "could not retrieve beacon state")
 	}
-	root, err := transition.CalculateStateRoot(
-		ctx,
-		beaconState,
-		block,
-	)
+	st, err := transition.CalculatePostState(ctx, beaconState, block)
 	if err != nil {
-		return vs.handleStateRootError(ctx, block, err)
+		return vs.handlePostBlockStateError(ctx, block, err)
 	}
-
-	log.WithField("beaconStateRoot", fmt.Sprintf("%#x", root)).Debugf("Computed state root")
-	return root[:], nil
+	return st, nil
 }
 
 type computeStateRootAttemptsKeyType string
@@ -631,8 +641,8 @@ type computeStateRootAttemptsKeyType string
 const computeStateRootAttemptsKey = computeStateRootAttemptsKeyType("compute-state-root-attempts")
 const maxComputeStateRootAttempts = 3
 
-// handleStateRootError retries block construction in some error cases.
-func (vs *Server) handleStateRootError(ctx context.Context, block interfaces.SignedBeaconBlock, err error) ([]byte, error) {
+// handlePostBlockStateError retries block construction in some error cases.
+func (vs *Server) handlePostBlockStateError(ctx context.Context, block interfaces.SignedBeaconBlock, err error) (state.BeaconState, error) {
 	if ctx.Err() != nil {
 		return nil, status.Errorf(codes.Canceled, "context error: %v", ctx.Err())
 	}
@@ -681,8 +691,8 @@ func (vs *Server) handleStateRootError(ctx context.Context, block interfaces.Sig
 	} else {
 		ctx = context.WithValue(ctx, computeStateRootAttemptsKey, v+1)
 	}
-	// recursive call to compute state root again
-	return vs.computeStateRoot(ctx, block)
+	// recursive call to compute post-block state again
+	return vs.computePostBlockState(ctx, block)
 }
 
 // Deprecated: The gRPC API will remain the default and fully supported through v8 (expected in 2026) but will be eventually removed in favor of REST API.

beacon-chain/rpc/prysm/v1alpha1/validator/proposer_test.go

@@ -1313,8 +1313,8 @@ func TestProposer_ComputeStateRoot_OK(t *testing.T) {
 	require.NoError(t, err)
 }
 
-func TestHandleStateRootError_MaxAttemptsReached(t *testing.T) {
-	// Test that handleStateRootError returns an error when max attempts is reached
+func TestHandlePostBlockStateError_MaxAttemptsReached(t *testing.T) {
+	// Test that handlePostBlockStateError returns an error when max attempts is reached
 	// instead of recursing infinitely.
 	ctx := t.Context()
 	vs := &Server{}
@@ -1327,15 +1327,15 @@ func TestHandleStateRootError_MaxAttemptsReached(t *testing.T) {
 	// Pre-seed the context with max attempts already reached
 	ctx = context.WithValue(ctx, computeStateRootAttemptsKey, maxComputeStateRootAttempts)
 
-	// Call handleStateRootError with a retryable error
-	_, err = vs.handleStateRootError(ctx, wsb, transition.ErrAttestationsSignatureInvalid)
+	// Call handlePostBlockStateError with a retryable error
+	_, err = vs.handlePostBlockStateError(ctx, wsb, transition.ErrAttestationsSignatureInvalid)
 
 	// Should return an error about max attempts instead of recursing
 	require.ErrorContains(t, "attempted max compute state root attempts", err)
 }
 
-func TestHandleStateRootError_IncrementsAttempts(t *testing.T) {
-	// Test that handleStateRootError properly increments the attempts counter
+func TestHandlePostBlockStateError_IncrementsAttempts(t *testing.T) {
+	// Test that handlePostBlockStateError properly increments the attempts counter
 	// and eventually fails after max attempts.
 	db := dbutil.SetupDB(t)
 	ctx := t.Context()
@@ -1357,10 +1357,10 @@ func TestHandleStateRootError_IncrementsAttempts(t *testing.T) {
 	// Add a state for the parent root so StateByRoot succeeds
 	require.NoError(t, stateGen.SaveState(ctx, parentRoot, beaconState))
 
-	// Call handleStateRootError with a retryable error - it will recurse
-	// but eventually hit the max attempts limit since CalculateStateRoot
+	// Call handlePostBlockStateError with a retryable error - it will recurse
+	// but eventually hit the max attempts limit since CalculatePostState
 	// will keep failing (no valid attestations, randao, etc.)
-	_, err = vs.handleStateRootError(ctx, wsb, transition.ErrAttestationsSignatureInvalid)
+	_, err = vs.handlePostBlockStateError(ctx, wsb, transition.ErrAttestationsSignatureInvalid)
 
 	// Should eventually fail - either with max attempts or another error
 	require.NotNil(t, err)

changelog/james-prysm_calculate-post-state.md

@@ -0,0 +1,3 @@
+### Ignored
+
+- refactors calculate state root and breaks up into calculate post state function.