feat(dot/parachain): implement validate candidate from exhaustive

dot/parachain/backing/candidate_backing_test.go

@@ -761,10 +761,10 @@ func TestValidateAndMakeAvailable(t *testing.T) {
 							Data: parachaintypes.ValidationCode{1, 2, 3},
 						}
 					case candidatevalidation.ValidateFromExhaustive:
+						ci := candidatevalidation.ExecutionError
 						data.Ch <- parachaintypes.OverseerFuncRes[candidatevalidation.ValidationResult]{
 							Data: candidatevalidation.ValidationResult{
-								IsValid: false,
-								Err:     errors.New("mock error validating candidate"),
+								InvalidResult: &ci,
 							},
 						}
 					default:
@@ -791,7 +791,7 @@ func TestValidateAndMakeAvailable(t *testing.T) {
 					case candidatevalidation.ValidateFromExhaustive:
 						data.Ch <- parachaintypes.OverseerFuncRes[candidatevalidation.ValidationResult]{
 							Data: candidatevalidation.ValidationResult{
-								IsValid: true,
+								ValidResult: &candidatevalidation.ValidValidationResult{},
 							},
 						}
 					case availabilitystore.StoreAvailableData:

dot/parachain/backing/per_relay_parent_state.go

@@ -316,8 +316,7 @@ func (rpState *perRelayParentState) validateAndMakeAvailable(
 	}
 
 	var bgValidationResult backgroundValidationResult
-
-	if validationResultRes.Data.IsValid { // Valid
+	if validationResultRes.Data.IsValid() { // Valid
 		// Important: the `av-store` subsystem will check if the erasure root of the `available_data`
 		// matches `expected_erasure_root` which was provided by the collator in the `CandidateReceipt`.
 		// This check is consensus critical and the `backing` subsystem relies on it for ensuring
@@ -343,8 +342,8 @@ func (rpState *perRelayParentState) validateAndMakeAvailable(
 			bgValidationResult = backgroundValidationResult{
 				outputs: &backgroundValidationOutputs{
 					candidateReceipt:        candidateReceipt,
-					candidateCommitments:    validationResultRes.Data.CandidateCommitments,
-					persistedValidationData: validationResultRes.Data.PersistedValidationData,
+					candidateCommitments:    validationResultRes.Data.ValidResult.CandidateCommitments,
+					persistedValidationData: validationResultRes.Data.ValidResult.PersistedValidationData,
 				},
 				candidate: nil,
 				err:       nil,
@@ -361,11 +360,11 @@ func (rpState *perRelayParentState) validateAndMakeAvailable(
 		}
 
 	} else { // Invalid
-		logger.Error(validationResultRes.Data.Err.Error())
+		logger.Error(validationResultRes.Data.InvalidResult.Error())
 		bgValidationResult = backgroundValidationResult{
 			outputs:   nil,
 			candidate: &candidateReceipt,
-			err:       validationResultRes.Data.Err,
+			err:       fmt.Errorf(validationResultRes.Data.InvalidResult.Error()),
 		}
 	}
 

dot/parachain/candidate-validation/candidate_validation.go

@@ -24,46 +24,54 @@ var (
 	ErrValidationInputOverLimit = errors.New("validation input is over the limit")
 )
 
+// CandidateValidation is a parachain subsystem that validates candidate parachain blocks
 type CandidateValidation struct {
 	wg       sync.WaitGroup
 	stopChan chan struct{}
 
 	SubsystemToOverseer chan<- any
 	OverseerToSubsystem <-chan any
+	ValidationHost      parachainruntime.ValidationHost
 }
 
+// NewCandidateValidation creates a new CandidateValidation subsystem
 func NewCandidateValidation(overseerChan chan<- any) *CandidateValidation {
 	candidateValidation := CandidateValidation{
 		SubsystemToOverseer: overseerChan,
 	}
-
 	return &candidateValidation
 }
 
+// Run starts the CandidateValidation subsystem
 func (cv *CandidateValidation) Run(context.Context, chan any, chan any) {
 	cv.wg.Add(1)
 	go cv.processMessages(&cv.wg)
 }
 
+// Name returns the name of the subsystem
 func (*CandidateValidation) Name() parachaintypes.SubSystemName {
 	return parachaintypes.CandidateValidation
 }
 
+// ProcessActiveLeavesUpdateSignal processes active leaves update signal
 func (*CandidateValidation) ProcessActiveLeavesUpdateSignal(parachaintypes.ActiveLeavesUpdateSignal) error {
 	// NOTE: this subsystem does not process active leaves update signal
 	return nil
 }
 
+// ProcessBlockFinalizedSignal processes block finalized signal
 func (*CandidateValidation) ProcessBlockFinalizedSignal(parachaintypes.BlockFinalizedSignal) error {
 	// NOTE: this subsystem does not process block finalized signal
 	return nil
 }
 
+// Stop stops the CandidateValidation subsystem
 func (cv *CandidateValidation) Stop() {
 	close(cv.stopChan)
 	cv.wg.Wait()
 }
 
+// processMessages processes messages sent to the CandidateValidation subsystem
 func (cv *CandidateValidation) processMessages(wg *sync.WaitGroup) {
 	defer wg.Done()
 	for {
@@ -74,7 +82,20 @@ func (cv *CandidateValidation) processMessages(wg *sync.WaitGroup) {
 			case ValidateFromChainState:
 				// TODO: implement functionality to handle ValidateFromChainState, see issue #3919
 			case ValidateFromExhaustive:
-				// TODO: implement functionality to handle ValidateFromExhaustive, see issue #3547
+				result, err := validateFromExhaustive(cv.ValidationHost, msg.PersistedValidationData,
+					msg.ValidationCode, msg.CandidateReceipt, msg.PoV)
+				if err != nil {
+					logger.Errorf("failed to validate from exhaustive: %w", err)
+					msg.Ch <- parachaintypes.OverseerFuncRes[ValidationResult]{
+						Data: *result,
+						Err:  err,
+					}
+				} else {
+					msg.Ch <- parachaintypes.OverseerFuncRes[ValidationResult]{
+						Data: *result,
+					}
+				}
+
 			case PreCheck:
 				// TODO: implement functionality to handle PreCheck, see issue #3921
 
@@ -100,6 +121,7 @@ type PoVRequestor interface {
 	RequestPoV(povHash common.Hash) parachaintypes.PoV
 }
 
+// getValidationData gets validation data for a parachain block from the runtime instance
 func getValidationData(runtimeInstance parachainruntime.RuntimeInstance, paraID uint32,
 ) (*parachaintypes.PersistedValidationData, *parachaintypes.ValidationCode, error) {
 
@@ -211,3 +233,90 @@ func validateFromChainState(runtimeInstance parachainruntime.RuntimeInstance, po
 
 	return &candidateCommitments, persistedValidationData, isValid, nil
 }
+
+// validateFromExhaustive validates a candidate parachain block with provided parameters
+func validateFromExhaustive(validationHost parachainruntime.ValidationHost,
+	persistedValidationData parachaintypes.PersistedValidationData,
+	validationCode parachaintypes.ValidationCode,
+	candidateReceipt parachaintypes.CandidateReceipt, pov parachaintypes.PoV) (
+	*ValidationResult, error) {
+
+	validationCodeHash := validationCode.Hash()
+	// basic checks
+	validationErr, internalErr := performBasicChecks(&candidateReceipt.Descriptor, persistedValidationData.MaxPovSize,
+		pov,
+		validationCodeHash)
+	if validationErr != nil {
+		validationResult := &ValidationResult{
+			InvalidResult: validationErr,
+		}
+		return validationResult, internalErr
+	}
+
+	validationParams := parachainruntime.ValidationParameters{
+		ParentHeadData:         persistedValidationData.ParentHead,
+		BlockData:              pov.BlockData,
+		RelayParentNumber:      persistedValidationData.RelayParentNumber,
+		RelayParentStorageRoot: persistedValidationData.RelayParentStorageRoot,
+	}
+
+	validationResult, err := validationHost.ValidateBlock(validationParams)
+	if err != nil {
+		ci := ExecutionError
+		return &ValidationResult{InvalidResult: &ci}, fmt.Errorf("executing validate_block: %w", err)
+	}
+
+	result := &ValidationResult{
+		ValidResult: &ValidValidationResult{
+			CandidateCommitments: parachaintypes.CandidateCommitments{
+				UpwardMessages:            validationResult.UpwardMessages,
+				HorizontalMessages:        validationResult.HorizontalMessages,
+				NewValidationCode:         validationResult.NewValidationCode,
+				HeadData:                  validationResult.HeadData,
+				ProcessedDownwardMessages: validationResult.ProcessedDownwardMessages,
+				HrmpWatermark:             validationResult.HrmpWatermark,
+			},
+			PersistedValidationData: persistedValidationData,
+		},
+	}
+	return result, nil
+}
+
+// performBasicChecks Does basic checks of a candidate. Provide the encoded PoV-block.
+// Returns CandidateInvalidity and internal error if any.
+func performBasicChecks(candidate *parachaintypes.CandidateDescriptor, maxPoVSize uint32,
+	pov parachaintypes.PoV, validationCodeHash parachaintypes.ValidationCodeHash) (validationError *CandidateInvalidity,
+	internalError error) {
+	povHash, err := pov.Hash()
+	if err != nil {
+		return nil, fmt.Errorf("hashing PoV: %w", err)
+	}
+
+	encodedPoV, err := pov.Encode()
+	if err != nil {
+		return nil, fmt.Errorf("encoding PoV: %w", err)
+	}
+	encodedPoVSize := uint32(len(encodedPoV))
+
+	if encodedPoVSize > maxPoVSize {
+		ci := ParamsTooLarge
+		return &ci, nil
+	}
+
+	if povHash != candidate.PovHash {
+		ci := PoVHashMismatch
+		return &ci, nil
+	}
+
+	if validationCodeHash != candidate.ValidationCodeHash {
+		ci := CodeHashMismatch
+		return &ci, nil
+	}
+
+	err = candidate.CheckCollatorSignature()
+	if err != nil {
+		ci := BadSignature
+		return &ci, nil
+	}
+	return nil, nil
+}