feat(dot/parachain): Confirm invalidity errors are implemented in candidate validation.

dot/parachain/candidate-validation/candidate_validation.go

@@ -164,6 +164,7 @@ func (cv *CandidateValidation) validateFromChainState(msg ValidateFromChainState
 
 	persistedValidationData, validationCode, err := getValidationData(runtimeInstance,
 		msg.CandidateReceipt.Descriptor.ParaID)
+
 	if err != nil {
 		logger.Errorf("getting validation data: %w", err)
 		msg.Ch <- parachaintypes.OverseerFuncRes[ValidationResult]{
@@ -172,24 +173,56 @@ func (cv *CandidateValidation) validateFromChainState(msg ValidateFromChainState
 		return
 	}
 
+	if persistedValidationData == nil {
+		badParent := BadParent
+		reason := ValidationResult{
+			Invalid: &badParent,
+		}
+		msg.Ch <- parachaintypes.OverseerFuncRes[ValidationResult]{
+			Data: reason,
+		}
+		return
+	}
 	validationTask := &ValidationTask{
 		PersistedValidationData: *persistedValidationData,
 		ValidationCode:          validationCode,
 		CandidateReceipt:        &msg.CandidateReceipt,
 		PoV:                     msg.Pov,
 		ExecutorParams:          msg.ExecutorParams,
-		// todo: implement PvfExecTimeoutKind, so that validate can be called with a timeout see issue: #3429
-		PvfExecTimeoutKind: parachaintypes.PvfExecTimeoutKind{},
 	}
 
 	result, err := cv.pvfHost.validate(validationTask)
 	if err != nil {
 		msg.Ch <- parachaintypes.OverseerFuncRes[ValidationResult]{
 			Err: err,
 		}
-	} else {
+		return
+	}
+	if !result.IsValid() {
 		msg.Ch <- parachaintypes.OverseerFuncRes[ValidationResult]{
 			Data: *result,
 		}
+		return
+	}
+	valid, err := runtimeInstance.ParachainHostCheckValidationOutputs(parachaintypes.ParaID(msg.CandidateReceipt.
+		Descriptor.ParaID), result.Valid.CandidateCommitments)
+	if err != nil {
+		msg.Ch <- parachaintypes.OverseerFuncRes[ValidationResult]{
+			Err: fmt.Errorf("check validation outputs: Bad request: %w", err),
+		}
+		return
+	}
+	if !valid {
+		invalidOutput := InvalidOutputs
+		reason := &ValidationResult{
+			Invalid: &invalidOutput,
+		}
+		msg.Ch <- parachaintypes.OverseerFuncRes[ValidationResult]{
+			Data: *reason,
+		}
+		return
+	}
+	msg.Ch <- parachaintypes.OverseerFuncRes[ValidationResult]{
+		Data: *result,
 	}
 }

dot/parachain/candidate-validation/candidate_validation_test.go

@@ -22,9 +22,11 @@ var (
 	paramsTooLarge   = ParamsTooLarge
 	codeHashMismatch = CodeHashMismatch
 	badSignature     = BadSignature
+	invalidOutputs   = InvalidOutputs
+	badParent        = BadParent
 )
 
-func createTestCandidateReceiptAndValidationCode(t *testing.T) (
+func createTestCandidateReceiptAndValidationCodeWParaId(t *testing.T, id uint32) (
 	parachaintypes.CandidateReceipt, parachaintypes.ValidationCode) {
 	// this wasm was achieved by building polkadot's adder test parachain
 	runtimeFilePath := "./testdata/test_parachain_adder.wasm"
@@ -38,7 +40,7 @@ func createTestCandidateReceiptAndValidationCode(t *testing.T) (
 	collatorKeypair, err := sr25519.GenerateKeypair()
 	require.NoError(t, err)
 
-	descriptor := makeValidCandidateDescriptor(t, 1000,
+	descriptor := makeValidCandidateDescriptor(t, id,
 		common.MustHexToHash("0xded542bacb3ca6c033a57676f94ae7c8f36834511deb44e3164256fd3b1c0de0"),
 		common.MustHexToHash("0x690d8f252ef66ab0f969c3f518f90012b849aa5ac94e1752c5e5ae5a8996de37"),
 		common.MustHexToHash("0xb608991ffc48dd405fd4b10e92eaebe2b5a2eedf44d0c3efb8997fdee8bebed9"),
@@ -107,7 +109,7 @@ func TestCandidateValidation_wasm_invalid_magic_number(t *testing.T) {
 func TestCandidateValidation_processMessageValidateFromExhaustive(t *testing.T) {
 	t.Parallel()
 
-	candidateReceipt, validationCode := createTestCandidateReceiptAndValidationCode(t)
+	candidateReceipt, validationCode := createTestCandidateReceiptAndValidationCodeWParaId(t, 1000)
 	candidateReceipt2 := candidateReceipt
 	candidateReceipt2.Descriptor.PovHash = common.MustHexToHash(
 		"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef")
@@ -261,7 +263,7 @@ func TestCandidateValidation_processMessageValidateFromExhaustive(t *testing.T)
 func TestCandidateValidation_processMessageValidateFromChainState(t *testing.T) {
 	t.Parallel()
 
-	candidateReceipt, validationCode := createTestCandidateReceiptAndValidationCode(t)
+	candidateReceipt, validationCode := createTestCandidateReceiptAndValidationCodeWParaId(t, 1000)
 	candidateReceipt2 := candidateReceipt
 	candidateReceipt2.Descriptor.PovHash = common.MustHexToHash(
 		"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef")
@@ -278,6 +280,11 @@ func TestCandidateValidation_processMessageValidateFromChainState(t *testing.T)
 	candidateReceipt5 := candidateReceipt
 	candidateReceipt5.Descriptor.ParaID = 5
 
+	candidateReceipt6, _ := createTestCandidateReceiptAndValidationCodeWParaId(t, 6)
+
+	candidateReceipt7 := candidateReceipt
+	candidateReceipt7.Descriptor.ParaID = 7
+
 	ctrl := gomock.NewController(t)
 	t.Cleanup(ctrl.Finish)
 
@@ -318,6 +325,16 @@ func TestCandidateValidation_processMessageValidateFromChainState(t *testing.T)
 	mockInstance.EXPECT().
 		ParachainHostValidationCode(uint32(1000), gomock.AssignableToTypeOf(parachaintypes.OccupiedCoreAssumption{})).
 		Return(&validationCode, nil)
+	validCandidateCommitments := parachaintypes.CandidateCommitments{
+		HeadData: parachaintypes.HeadData{Data: []byte{2, 0, 0, 0, 0, 0, 0, 0, 123, 207, 206, 8, 219, 227,
+			136, 82, 236, 169, 14, 100, 45, 100, 31, 177, 154, 160, 220, 245, 59, 106, 76, 168, 122, 109,
+			164, 169, 22, 46, 144, 39, 103, 92, 31, 78, 66, 72, 252, 64, 24, 194, 129, 162, 128, 1, 77, 147,
+			200, 229, 189, 242, 111, 198, 236, 139, 16, 143, 19, 245, 113, 233, 138, 210}},
+		ProcessedDownwardMessages: 0,
+		HrmpWatermark:             1,
+	}
+	mockInstance.EXPECT().ParachainHostCheckValidationOutputs(parachaintypes.ParaID(1000),
+		validCandidateCommitments).Return(true, nil)
 
 	mockInstance.EXPECT().
 		ParachainHostPersistedValidationData(
@@ -355,9 +372,26 @@ func TestCandidateValidation_processMessageValidateFromChainState(t *testing.T)
 		ParachainHostValidationCode(uint32(5), gomock.AssignableToTypeOf(parachaintypes.OccupiedCoreAssumption{})).
 		Return(&validationCode, nil)
 
+	mockInstance.EXPECT().
+		ParachainHostPersistedValidationData(uint32(6), gomock.AssignableToTypeOf(parachaintypes.OccupiedCoreAssumption{})).
+		Return(&expectedPersistedValidationData, nil)
+	mockInstance.EXPECT().
+		ParachainHostValidationCode(uint32(6), gomock.AssignableToTypeOf(parachaintypes.OccupiedCoreAssumption{})).
+		Return(&validationCode, nil)
+	mockInstance.EXPECT().ParachainHostCheckValidationOutputs(parachaintypes.ParaID(6),
+		validCandidateCommitments).Return(false, nil)
+
+	mockInstance.EXPECT().
+		ParachainHostPersistedValidationData(uint32(7), gomock.AssignableToTypeOf(parachaintypes.
+			OccupiedCoreAssumption{})).
+		Return(nil, nil)
+	mockInstance.EXPECT().
+		ParachainHostValidationCode(uint32(7), gomock.AssignableToTypeOf(parachaintypes.OccupiedCoreAssumption{})).
+		Return(&validationCode, nil)
+
 	mockBlockState := NewMockBlockState(ctrl)
 	mockBlockState.EXPECT().GetRuntime(common.MustHexToHash(
-		"0xded542bacb3ca6c033a57676f94ae7c8f36834511deb44e3164256fd3b1c0de0")).Return(mockInstance, nil).Times(5)
+		"0xded542bacb3ca6c033a57676f94ae7c8f36834511deb44e3164256fd3b1c0de0")).Return(mockInstance, nil).Times(7)
 
 	bd, err := scale.Marshal(BlockDataInAdderParachain{
 		State: uint64(1),
@@ -418,21 +452,32 @@ func TestCandidateValidation_processMessageValidateFromChainState(t *testing.T)
 				Invalid: &badSignature,
 			},
 		},
+		"invalid_outputs": {
+			msg: ValidateFromChainState{
+				CandidateReceipt: candidateReceipt6,
+				Pov:              pov,
+			},
+			want: &ValidationResult{
+				Invalid: &invalidOutputs,
+			},
+		},
+		"bad_parent": {
+			msg: ValidateFromChainState{
+				CandidateReceipt: candidateReceipt7,
+				Pov:              pov,
+			},
+			want: &ValidationResult{
+				Invalid: &badParent,
+			},
+		},
 		"happy_path": {
 			msg: ValidateFromChainState{
 				CandidateReceipt: candidateReceipt,
 				Pov:              pov,
 			},
 			want: &ValidationResult{
 				Valid: &Valid{
-					CandidateCommitments: parachaintypes.CandidateCommitments{
-						HeadData: parachaintypes.HeadData{Data: []byte{2, 0, 0, 0, 0, 0, 0, 0, 123, 207, 206, 8, 219, 227,
-							136, 82, 236, 169, 14, 100, 45, 100, 31, 177, 154, 160, 220, 245, 59, 106, 76, 168, 122, 109,
-							164, 169, 22, 46, 144, 39, 103, 92, 31, 78, 66, 72, 252, 64, 24, 194, 129, 162, 128, 1, 77, 147,
-							200, 229, 189, 242, 111, 198, 236, 139, 16, 143, 19, 245, 113, 233, 138, 210}},
-						ProcessedDownwardMessages: 0,
-						HrmpWatermark:             1,
-					},
+					CandidateCommitments: validCandidateCommitments,
 					PersistedValidationData: parachaintypes.PersistedValidationData{
 						ParentHead: parachaintypes.HeadData{Data: []byte{1, 0, 0, 0, 0, 0, 0, 0, 1,
 							2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7,

dot/parachain/candidate-validation/host_test.go

@@ -12,7 +12,7 @@ import (
 
 func TestHost_validate(t *testing.T) {
 	t.Parallel()
-	candidateReceipt, validationCode := createTestCandidateReceiptAndValidationCode(t)
+	candidateReceipt, validationCode := createTestCandidateReceiptAndValidationCodeWParaId(t, 1000)
 	candidateReceipt2 := candidateReceipt
 	candidateReceipt2.Descriptor.PovHash = common.MustHexToHash(
 		"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef")

dot/parachain/candidate-validation/mocks_generate_test.go

@@ -6,3 +6,4 @@ package candidatevalidation
 //go:generate mockgen -destination=mocks_test.go -package=$GOPACKAGE . PoVRequestor
 //go:generate mockgen -destination=mocks_blockstate_test.go -package=$GOPACKAGE . BlockState
 //go:generate mockgen -destination=mocks_instance_test.go -package $GOPACKAGE github.com/ChainSafe/gossamer/lib/runtime Instance
+//go:generate mockgen -destination=mocks_validation_instance_test.go -package $GOPACKAGE github.com/ChainSafe/gossamer/dot/parachain/runtime ValidatorInstance

dot/parachain/candidate-validation/worker.go

@@ -1,6 +1,9 @@
 package candidatevalidation
 
 import (
+	"fmt"
+	"time"
+
 	parachainruntime "github.com/ChainSafe/gossamer/dot/parachain/runtime"
 	parachaintypes "github.com/ChainSafe/gossamer/dot/parachain/types"
 )
@@ -16,6 +19,7 @@ type workerTask struct {
 	work             parachainruntime.ValidationParameters
 	maxPoVSize       uint32
 	candidateReceipt *parachaintypes.CandidateReceipt
+	timeoutKind      parachaintypes.PvfExecTimeoutKind
 }
 
 func newWorker(validationCode parachaintypes.ValidationCode) (*worker, error) {
@@ -31,7 +35,30 @@ func newWorker(validationCode parachaintypes.ValidationCode) (*worker, error) {
 	}, nil
 }
 
+type resultWithError struct {
+	result *parachainruntime.ValidationResult
+	err    error
+}
+
+func determineTimeout(timeoutKind parachaintypes.PvfExecTimeoutKind) time.Duration {
+	value, err := timeoutKind.Value()
+	if err != nil {
+		return 2 * time.Second
+	}
+	switch value.(type) {
+	case parachaintypes.Backing:
+		return 2 * time.Second
+	case parachaintypes.Approval:
+		return 12 * time.Second
+	default:
+		return 2 * time.Second
+	}
+}
+
 func (w *worker) executeRequest(task *workerTask) (*ValidationResult, error) {
+	if task == nil {
+		return nil, fmt.Errorf("task is nil")
+	}
 	logger.Debugf("[EXECUTING] worker %x task %v", w.workerID, task.work)
 	candidateHash, err := parachaintypes.GetCandidateHash(task.candidateReceipt)
 	if err != nil {
@@ -42,10 +69,33 @@ func (w *worker) executeRequest(task *workerTask) (*ValidationResult, error) {
 		logger.Debugf("candidate %x already processed", candidateHash)
 		return processed, nil
 	}
-	validationResult, err := w.instance.ValidateBlock(task.work)
-	if err != nil {
-		logger.Errorf("executing validate_block: %w", err)
-		reasonForInvalidity := ExecutionError
+
+	var validationResult *parachainruntime.ValidationResult
+	validationResultCh := make(chan (*resultWithError))
+	timeoutDuration := determineTimeout(task.timeoutKind)
+
+	go func() {
+		result, err := w.instance.ValidateBlock(task.work)
+		if err != nil {
+			validationResultCh <- &resultWithError{result: nil, err: err}
+		}
+		validationResultCh <- &resultWithError{
+			result: result,
+		}
+	}()
+
+	select {
+	case validationResultWErr := <-validationResultCh:
+		if validationResultWErr.err != nil {
+			logger.Errorf("executing validate_block: %w", err)
+			reasonForInvalidity := ExecutionError
+			return &ValidationResult{Invalid: &reasonForInvalidity}, nil //nolint
+		}
+		validationResult = validationResultWErr.result
+
+	case <-time.After(timeoutDuration):
+		logger.Errorf("validation timed out")
+		reasonForInvalidity := Timeout
 		return &ValidationResult{Invalid: &reasonForInvalidity}, nil
 	}
 

dot/parachain/candidate-validation/worker_pool.go

@@ -149,10 +149,12 @@ func (v *workerPool) executeRequest(msg *ValidationTask) (*ValidationResult, err
 		RelayParentNumber:      msg.PersistedValidationData.RelayParentNumber,
 		RelayParentStorageRoot: msg.PersistedValidationData.RelayParentStorageRoot,
 	}
+
 	workTask := &workerTask{
 		work:             validationParams,
 		maxPoVSize:       msg.PersistedValidationData.MaxPovSize,
 		candidateReceipt: msg.CandidateReceipt,
+		timeoutKind:      msg.PvfExecTimeoutKind,
 	}
 	return worker.executeRequest(workTask)