feat: contract reference validation

packages/rs-dpp/src/data_contract/document_type/class_methods/try_from_schema/mod.rs

@@ -473,4 +473,60 @@ mod tests {
         ));
         assert!(!reference.must_exist);
     }
+
+    #[test]
+    fn should_parse_refers_to_with_contract_target() {
+        let platform_version = PlatformVersion::latest();
+        let config =
+            DataContractConfig::default_for_version(platform_version).expect("config should build");
+
+        let schema = json!({
+            "type": "object",
+            "properties": {
+                "toContractId": {
+                    "type": "array",
+                    "byteArray": true,
+                    "minItems": 32,
+                    "maxItems": 32,
+                    "contentMediaType": "application/x.dash.dpp.identifier",
+                    "position": 0,
+                    "refersTo": {
+                        "type": "contract"
+                    }
+                }
+            },
+            "required": [],
+            "additionalProperties": false
+        });
+
+        let value = platform_value::to_value(schema).expect("schema should convert");
+
+        let document_type = DocumentType::try_from_schema(
+            Identifier::random(),
+            0,
+            config.version(),
+            "msg",
+            value,
+            None,
+            &BTreeMap::new(),
+            &config,
+            false,
+            &mut vec![],
+            platform_version,
+        )
+        .expect("should parse");
+
+        let reference = document_type
+            .as_ref()
+            .flattened_properties()
+            .get("toContractId")
+            .and_then(|p| p.reference.clone())
+            .expect("reference should be present");
+
+        assert!(matches!(
+            reference.target,
+            DocumentPropertyReferenceTarget::Contract
+        ));
+        assert!(reference.must_exist);
+    }
 }

packages/rs-drive-abci/src/execution/types/execution_operation/mod.rs

@@ -75,6 +75,7 @@ pub enum ValidationOperation {
     Protocol(ProtocolValidationOperation),
     RetrieveIdentityTokenBalance,
     RetrieveIdentity(RetrieveIdentityInfo),
+    RetrieveContract,
     RetrievePrefundedSpecializedBalance,
     RetrieveAddressNonceAndBalance(u16),
     PerformNetworkThresholdSigning,
@@ -199,6 +200,19 @@ impl ValidationOperation {
                             "execution processing fee overflow error",
                         ))?;
                 }
+                ValidationOperation::RetrieveContract => {
+                    fee_result.processing_fee = fee_result
+                        .processing_fee
+                        .checked_add(
+                            platform_version
+                                .fee_version
+                                .processing
+                                .fetch_contract_processing_cost,
+                        )
+                        .ok_or(ExecutionError::Overflow(
+                            "execution processing fee overflow error",
+                        ))?;
+                }
                 ValidationOperation::RetrievePrefundedSpecializedBalance => {
                     let operation_cost = platform_version
                         .fee_version

packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/batch/action_validation/document/document_reference_validation/v0/mod.rs

@@ -109,7 +109,20 @@ fn validate_document_type_references_v0(
                     return Ok(validation_result);
                 }
             }
-            _ => continue,
+            DocumentPropertyReferenceTarget::Contract => {
+                let validation_result = validate_contract_reference_v0(
+                    document_data,
+                    path,
+                    reference.must_exist,
+                    platform,
+                    transaction,
+                    execution_context,
+                    platform_version,
+                )?;
+                if !validation_result.is_valid() {
+                    return Ok(validation_result);
+                }
+            }
         }
     }
 
@@ -170,3 +183,55 @@ fn validate_identity_reference_v0(
 
     Ok(SimpleConsensusValidationResult::new())
 }
+
+fn validate_contract_reference_v0(
+    document_data: &BTreeMap<String, Value>,
+    path: &str,
+    must_exist: bool,
+    platform: &PlatformStateRef,
+    transaction: TransactionArg,
+    execution_context: &mut StateTransitionExecutionContext,
+    platform_version: &PlatformVersion,
+) -> Result<SimpleConsensusValidationResult, Error> {
+    if !must_exist {
+        return Ok(SimpleConsensusValidationResult::new());
+    }
+
+    let contract_bytes = match document_data.get_optional_identifier_at_path(path) {
+        Ok(Some(contract_bytes)) => contract_bytes,
+        Ok(None) => {
+            return Ok(SimpleConsensusValidationResult::new_with_error(
+                InvalidIdentifierError::new(path.to_string(), "not set".to_string()).into(),
+            ))
+        }
+        Err(err) => {
+            return Ok(SimpleConsensusValidationResult::new_with_error(
+                InvalidIdentifierError::new(path.to_string(), err.to_string()).into(),
+            ))
+        }
+    };
+
+    execution_context.add_operation(ValidationOperation::RetrieveContract);
+
+    let maybe_contract = platform
+        .drive
+        .fetch_contract(contract_bytes, None, None, transaction, platform_version)
+        .value?;
+
+    if maybe_contract.is_none() {
+        let missing_id =
+            Identifier::from_bytes(&contract_bytes).map_err(|e| Error::Protocol(e.into()))?;
+
+        return Ok(SimpleConsensusValidationResult::new_with_error(
+            ConsensusError::StateError(StateError::ReferencedEntityNotFoundError(
+                ReferencedEntityNotFoundError::new(
+                    missing_id,
+                    DocumentPropertyReferenceTarget::Contract,
+                    path.to_string(),
+                ),
+            )),
+        ));
+    }
+
+    Ok(SimpleConsensusValidationResult::new())
+}

packages/rs-drive-abci/src/execution/validation/state_transition/state_transitions/batch/tests/document/creation.rs

@@ -56,6 +56,8 @@ mod creation_tests {
         "tests/supporting_files/contract/reference-validation/reference-validation-contract-must-exist-false.json";
     const REFERENCE_VALIDATION_NESTED_CONTRACT_PATH: &str =
         "tests/supporting_files/contract/reference-validation/reference-validation-contract-nested.json";
+    const REFERENCE_VALIDATION_CONTRACT_REFERENCE_PATH: &str =
+        "tests/supporting_files/contract/reference-validation/reference-validation-contract-refers-to-contract.json";
 
     // Helper to run document creation with custom reference mutations.
     fn run_reference_validation_creation_with_mutator<F>(
@@ -155,6 +157,103 @@ mod creation_tests {
             .clone()
     }
 
+    fn run_contract_reference_creation_with_mutator<F>(
+        contract_path: &str,
+        mutator: F,
+    ) -> StateTransitionExecutionResult
+    where
+        F: FnOnce(&mut Document, Identifier, Identifier, Identifier),
+    {
+        let platform_version = PlatformVersion::latest();
+        let mut platform = TestPlatformBuilder::new()
+            .with_latest_protocol_version()
+            .build_with_mock_rpc()
+            .set_genesis_state();
+
+        let mut rng = StdRng::seed_from_u64(433);
+
+        let platform_state = platform.state.load();
+
+        let (identity, signer, key) = setup_identity(&mut platform, 958, dash_to_credits!(0.1));
+        let (other_identity, ..) = setup_identity(&mut platform, 959, dash_to_credits!(0.1));
+
+        let contract = setup_contract(
+            &platform.drive,
+            contract_path,
+            None,
+            None,
+            None::<fn(&mut DataContract)>,
+            None,
+            None,
+        );
+
+        let message = contract
+            .document_type_for_name("message")
+            .expect("expected a message document type");
+
+        let entropy = Bytes32::random_with_rng(&mut rng);
+
+        let mut document = message
+            .random_document_with_identifier_and_entropy(
+                &mut rng,
+                identity.id(),
+                entropy,
+                DocumentFieldFillType::FillIfNotRequired,
+                DocumentFieldFillSize::AnyDocumentFillSize,
+                platform_version,
+            )
+            .expect("expected a random document");
+
+        mutator(&mut document, identity.id(), other_identity.id(), contract.id());
+
+        let documents_batch_create_transition =
+            BatchTransition::new_document_creation_transition_from_document(
+                document,
+                message,
+                entropy.0,
+                &key,
+                2,
+                0,
+                None,
+                &signer,
+                platform_version,
+                None,
+            )
+            .expect("expect to create documents batch transition");
+
+        let documents_batch_create_serialized_transition = documents_batch_create_transition
+            .serialize_to_bytes()
+            .expect("expected documents batch serialized state transition");
+
+        let transaction = platform.drive.grove.start_transaction();
+
+        let processing_result = platform
+            .platform
+            .process_raw_state_transitions(
+                &[documents_batch_create_serialized_transition],
+                &platform_state,
+                &BlockInfo::default(),
+                &transaction,
+                platform_version,
+                false,
+                None,
+            )
+            .expect("expected to process state transition");
+
+        platform
+            .drive
+            .grove
+            .commit_transaction(transaction)
+            .unwrap()
+            .expect("expected to commit transaction");
+
+        processing_result
+            .execution_results()
+            .first()
+            .expect("expected one execution result")
+            .clone()
+    }
+
     #[test]
     fn test_document_creation() {
         let platform_version = PlatformVersion::latest();
@@ -4116,4 +4215,37 @@ mod creation_tests {
             }
         );
     }
+
+    #[test]
+    fn test_document_creation_succeeds_when_referenced_contract_exists() {
+        let result = run_contract_reference_creation_with_mutator(
+            REFERENCE_VALIDATION_CONTRACT_REFERENCE_PATH,
+            |document, _, _, contract_id| {
+                document.set("toContractId", contract_id.into());
+            },
+        );
+
+        assert_matches!(
+            result,
+            StateTransitionExecutionResult::SuccessfulExecution { .. }
+        );
+    }
+
+    #[test]
+    fn test_document_creation_fails_when_referenced_contract_missing() {
+        let result = run_contract_reference_creation_with_mutator(
+            REFERENCE_VALIDATION_CONTRACT_REFERENCE_PATH,
+            |document, _, _, _| {
+                document.set("toContractId", Identifier::random().into());
+            },
+        );
+
+        assert_matches!(
+            result,
+            PaidConsensusError {
+                error: ConsensusError::StateError(StateError::ReferencedEntityNotFoundError(_)),
+                ..
+            }
+        );
+    }
 }