feat(dot/parachain): implement candidate validation pre-check

dot/parachain/backing/per_relay_parent_state.go

@@ -14,9 +14,7 @@ import (
 	provisionermessages "github.com/ChainSafe/gossamer/dot/parachain/provisioner/messages"
 	statementedistributionmessages "github.com/ChainSafe/gossamer/dot/parachain/statement-distribution/messages"
 	parachaintypes "github.com/ChainSafe/gossamer/dot/parachain/types"
-	"github.com/ChainSafe/gossamer/lib/runtime"
-	wazero_runtime "github.com/ChainSafe/gossamer/lib/runtime/wazero"
-
+	"github.com/ChainSafe/gossamer/dot/parachain/util"
 	"github.com/ChainSafe/gossamer/lib/common"
 )
 
@@ -288,7 +286,7 @@ func (rpState *perRelayParentState) validateAndMakeAvailable(
 		return fmt.Errorf("getting validation code by hash: %w", err)
 	}
 
-	executorParams, err := executorParamsAtRelayParent(rt, relayParent)
+	executorParams, err := util.ExecutorParamsAtRelayParent(rt, relayParent)
 	if err != nil {
 		return fmt.Errorf("getting executor params for relay parent %s: %w", relayParent, err)
 	}
@@ -383,32 +381,6 @@ func (rpState *perRelayParentState) validateAndMakeAvailable(
 	return nil
 }
 
-func executorParamsAtRelayParent(rt runtime.Instance, relayParent common.Hash,
-) (*parachaintypes.ExecutorParams, error) {
-	sessionIndex, err := rt.ParachainHostSessionIndexForChild()
-	if err != nil {
-		return nil, fmt.Errorf("getting session index for relay parent %s: %w", relayParent, err)
-	}
-
-	executorParams, err := rt.ParachainHostSessionExecutorParams(sessionIndex)
-	if err != nil {
-		if errors.Is(err, wazero_runtime.ErrExportFunctionNotFound) {
-			// Runtime doesn't yet support the api requested,
-			// should execute anyway with default set of parameters.
-			defaultExecutorParams := parachaintypes.NewExecutorParams()
-			return &defaultExecutorParams, nil
-		}
-		return nil, err
-	}
-
-	if executorParams == nil {
-		// should never happen
-		return nil, fmt.Errorf("executor params for relay parent %s is nil", relayParent)
-	}
-
-	return executorParams, nil
-}
-
 func getPovFromValidator(
 	subSystemToOverseer chan<- any,
 	chRelayParentAndCommand chan relayParentAndCommand,

dot/parachain/candidate-validation/candidate_validation.go

@@ -7,9 +7,11 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"time"
 
 	parachainruntime "github.com/ChainSafe/gossamer/dot/parachain/runtime"
 	parachaintypes "github.com/ChainSafe/gossamer/dot/parachain/types"
+	"github.com/ChainSafe/gossamer/dot/parachain/util"
 	"github.com/ChainSafe/gossamer/lib/common"
 	"github.com/ChainSafe/gossamer/lib/runtime"
 )
@@ -99,7 +101,12 @@ func (cv *CandidateValidation) processMessage(msg any) {
 		}
 
 	case PreCheck:
-		panic("TODO: implement functionality to handle PreCheck, see issue #3921")
+		outcome, err := cv.precheckPvF(msg.RelayParent, msg.ValidationCodeHash)
+		if err != nil {
+			logger.Errorf("failed to precheck: %w", err)
+		}
+		logger.Debugf("Precheck outcome: %v", outcome)
+		msg.ResponseSender <- outcome
 
 	case parachaintypes.ActiveLeavesUpdateSignal:
 		_ = cv.ProcessActiveLeavesUpdateSignal(msg)
@@ -226,3 +233,76 @@ func (cv *CandidateValidation) validateFromChainState(msg ValidateFromChainState
 		Data: *result,
 	}
 }
+
+// precheckPvF prechecks the parachain validation function by retrieving the validation code from the runtime instance
+// and calling the precheck method on the pvf host. It returns the precheck outcome.
+func (cv *CandidateValidation) precheckPvF(relayParent common.Hash, validationCodeHash parachaintypes.
+	ValidationCodeHash) (PreCheckOutcome, error) {
+	runtimeInstance, err := cv.BlockState.GetRuntime(relayParent)
+	if err != nil {
+		return PreCheckOutcomeFailed, fmt.Errorf("failed to get runtime instance: %w", err)
+	}
+
+	code, err := runtimeInstance.ParachainHostValidationCodeByHash(common.Hash(validationCodeHash))
+	if err != nil {
+		return PreCheckOutcomeFailed, fmt.Errorf("failed to get validation code by hash: %w", err)
+	}
+
+	executorParams, err := util.ExecutorParamsAtRelayParent(runtimeInstance, relayParent)
+	if err != nil {
+		return PreCheckOutcomeInvalid, fmt.Errorf("failed to acquire params for the session, thus voting against: %w", err)
+	}
+
+	kind := parachaintypes.NewPvfPrepTimeoutKind()
+	err = kind.SetValue(parachaintypes.Precheck{})
+	if err != nil {
+		return PreCheckOutcomeFailed, fmt.Errorf("failed to set value: %w", err)
+	}
+
+	prepTimeout := pvfPrepTimeout(*executorParams, kind)
+
+	pvf := PvFPrepData{
+		code:           *code,
+		codeHash:       validationCodeHash,
+		executorParams: *executorParams,
+		prepTimeout:    prepTimeout,
+		prepKind:       kind,
+	}
+	err = cv.pvfHost.precheck(pvf)
+	if err != nil {
+		return PreCheckOutcomeFailed, fmt.Errorf("failed to precheck: %w", err)
+	}
+	return PreCheckOutcomeValid, nil
+}
+
+// pvfPrepTimeout To determine the amount of timeout time for the pvf execution.
+//
+//	The time period after which the preparation worker is considered
+//
+// unresponsive and will be killed.
+func pvfPrepTimeout(params parachaintypes.ExecutorParams, kind parachaintypes.PvfPrepTimeoutKind) time.Duration {
+	for _, param := range params {
+		val, err := param.Value()
+		if err != nil {
+			logger.Errorf("determining parameter values %w", err)
+		}
+		switch val := val.(type) {
+		case parachaintypes.PvfPrepTimeout:
+			// convert milliseconds to nanoseconds and cast to time.Duration.
+			return time.Duration(val.Millisec * 1000000)
+		}
+	}
+
+	timeoutKind, err := kind.Value()
+	if err != nil {
+		return time.Second * 2
+	}
+	switch timeoutKind.(type) {
+	case parachaintypes.Precheck:
+		return time.Second * 2
+	case parachaintypes.Lenient:
+		return time.Second * 10
+	default:
+		return time.Second * 2
+	}
+}

dot/parachain/candidate-validation/candidate_validation_test.go

@@ -5,6 +5,7 @@ package candidatevalidation
 
 import (
 	"context"
+	"fmt"
 	"os"
 	"testing"
 
@@ -508,3 +509,125 @@ func TestCandidateValidation_processMessageValidateFromChainState(t *testing.T)
 		})
 	}
 }
+
+func Test_precheckPvF(t *testing.T) {
+	t.Parallel()
+	ctrl := gomock.NewController(t)
+	t.Cleanup(ctrl.Finish)
+	candidate, validationCode := createTestCandidateReceiptAndValidationCodeWParaId(t, 1000)
+
+	mockInstance := NewMockInstance(ctrl)
+	mockInstance.EXPECT().ParachainHostValidationCodeByHash(common.Hash(candidate.Descriptor.ValidationCodeHash)).
+		Return(&validationCode, nil)
+	mockInstance.EXPECT().ParachainHostSessionIndexForChild().Return(parachaintypes.SessionIndex(1), nil)
+
+	executionParams := parachaintypes.ExecutorParams{}
+	timeout := parachaintypes.PvfPrepTimeout{
+		PvfPrepTimeoutKind: func() parachaintypes.PvfPrepTimeoutKind {
+			kind := parachaintypes.NewPvfPrepTimeoutKind()
+			if err := kind.SetValue(parachaintypes.Precheck{}); err != nil {
+				panic(err)
+			}
+			return kind
+		}(),
+		Millisec: 1000,
+	}
+	timeoutParam := parachaintypes.NewExecutorParam()
+	err := timeoutParam.SetValue(timeout)
+	require.NoError(t, err)
+	executionParams = append(executionParams, timeoutParam)
+	mockInstance.EXPECT().ParachainHostSessionExecutorParams(parachaintypes.SessionIndex(1)).Return(&executionParams,
+		nil)
+
+	mockInstanceExecutorError := NewMockInstance(ctrl)
+	mockInstanceExecutorError.EXPECT().ParachainHostValidationCodeByHash(common.MustHexToHash("0x04")).Return(
+		&parachaintypes.ValidationCode{}, nil)
+	mockInstanceExecutorError.EXPECT().ParachainHostSessionIndexForChild().Return(parachaintypes.SessionIndex(2), nil)
+	mockInstanceExecutorError.EXPECT().ParachainHostSessionExecutorParams(parachaintypes.SessionIndex(2)).Return(
+		nil, fmt.Errorf("executor params not found"))
+
+	mockInstanceShortTimeout := NewMockInstance(ctrl)
+	mockInstanceShortTimeout.EXPECT().ParachainHostValidationCodeByHash(common.MustHexToHash("0x0404")).Return(
+		&validationCode, nil)
+	mockInstanceShortTimeout.EXPECT().ParachainHostSessionIndexForChild().Return(parachaintypes.SessionIndex(3), nil)
+	executionParamsShortTimeout := parachaintypes.ExecutorParams{}
+	timeoutShort := parachaintypes.PvfPrepTimeout{
+		PvfPrepTimeoutKind: func() parachaintypes.PvfPrepTimeoutKind {
+			kind := parachaintypes.NewPvfPrepTimeoutKind()
+			if err := kind.SetValue(parachaintypes.Precheck{}); err != nil {
+				panic(err)
+			}
+			return kind
+		}(),
+		Millisec: 1,
+	}
+	timeoutShortParam := parachaintypes.NewExecutorParam()
+	err = timeoutShortParam.SetValue(timeoutShort)
+	require.NoError(t, err)
+	executionParamsShortTimeout = append(executionParamsShortTimeout, timeoutShortParam)
+	mockInstanceShortTimeout.EXPECT().ParachainHostSessionExecutorParams(parachaintypes.SessionIndex(3)).Return(
+		&executionParamsShortTimeout, nil)
+
+	mockBlockState := NewMockBlockState(ctrl)
+	mockBlockState.EXPECT().GetRuntime(common.MustHexToHash("0x01")).Return(nil, fmt.Errorf("runtime not found"))
+	mockBlockState.EXPECT().GetRuntime(common.MustHexToHash("0x02")).Return(mockInstance, nil)
+	mockBlockState.EXPECT().GetRuntime(common.MustHexToHash("0x03")).Return(mockInstanceExecutorError, nil)
+	mockBlockState.EXPECT().GetRuntime(common.MustHexToHash("0x04")).Return(mockInstanceShortTimeout, nil)
+
+	tests := map[string]struct {
+		msg            PreCheck
+		expectedResult PreCheckOutcome
+		expectedError  error
+	}{
+		"validation_code_not_found": {
+			msg: PreCheck{
+				RelayParent: common.MustHexToHash("0x01"),
+			},
+			expectedResult: PreCheckOutcomeFailed,
+			expectedError:  fmt.Errorf("failed to get runtime instance: runtime not found"),
+		},
+		"invalid_executor_params": {
+			msg: PreCheck{
+				RelayParent:        common.MustHexToHash("0x03"),
+				ValidationCodeHash: parachaintypes.ValidationCodeHash(common.MustHexToHash("0x04")),
+			},
+			expectedResult: PreCheckOutcomeInvalid,
+			expectedError: fmt.Errorf("failed to acquire params for the session, thus voting against: " +
+				"executor params not found"),
+		},
+		"precheck_timeout": {
+			msg: PreCheck{
+				RelayParent:        common.MustHexToHash("0x04"),
+				ValidationCodeHash: parachaintypes.ValidationCodeHash(common.MustHexToHash("0x0404")),
+			},
+			expectedResult: PreCheckOutcomeFailed,
+			expectedError:  fmt.Errorf("failed to precheck: failed to create a new worker: precheck timed out"),
+		},
+		"happy_path": {
+			msg: PreCheck{
+				RelayParent:        common.MustHexToHash("0x02"),
+				ValidationCodeHash: candidate.Descriptor.ValidationCodeHash,
+			},
+			expectedResult: PreCheckOutcomeValid,
+		},
+	}
+	for name, tt := range tests {
+		tt := tt
+
+		t.Run(name, func(t *testing.T) {
+			t.Parallel()
+
+			candidateValidationSubsystem := CandidateValidation{
+				pvfHost:    newValidationHost(),
+				BlockState: mockBlockState,
+			}
+			result, err := candidateValidationSubsystem.precheckPvF(tt.msg.RelayParent, tt.msg.ValidationCodeHash)
+			require.Equal(t, tt.expectedResult, result)
+			if tt.expectedError != nil {
+				require.EqualError(t, err, tt.expectedError.Error())
+			} else {
+				require.NoError(t, err)
+			}
+		})
+	}
+}

dot/parachain/candidate-validation/host.go

@@ -20,6 +20,9 @@ func newValidationHost() *host {
 		workerPool: newWorkerPool(),
 	}
 }
+func (v *host) precheck(data PvFPrepData) error {
+	return v.workerPool.handlePrecheckPvF(data)
+}
 
 func (v *host) validate(msg *ValidationTask) (*ValidationResult, error) {
 	validationCodeHash := msg.ValidationCode.Hash()

dot/parachain/candidate-validation/messages.go

@@ -37,7 +37,7 @@ type ValidateFromExhaustive struct {
 type PreCheck struct {
 	RelayParent        common.Hash
 	ValidationCodeHash parachaintypes.ValidationCodeHash
-	PreCheckOutcome    chan PreCheckOutcome
+	ResponseSender     chan PreCheckOutcome
 }
 
 // PreCheckOutcome represents the outcome of the candidate-validation pre-check request