chore(dpp): version InstantAssetLockProof.validate_structure

packages/rs-dpp/src/identity/state_transition/asset_lock_proof/instant/instant_asset_lock_proof.rs

@@ -10,7 +10,8 @@ use crate::consensus::basic::identity::IdentityAssetLockProofLockedTransactionMi
 use serde::de::Error as DeError;
 use serde::ser::Error as SerError;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
-use platform_version::version::PlatformVersion;
+use platform_version::version::{FeatureVersion, PlatformVersion};
+use crate::identity::state_transition::asset_lock_proof::instant::methods;
 use crate::identity::state_transition::asset_lock_proof::validate_asset_lock_transaction_structure::validate_asset_lock_transaction_structure;
 
 use crate::prelude::Identifier;
@@ -159,36 +160,29 @@ impl InstantAssetLockProof {
             .map_err(|e| ProtocolError::EncodingError(e.to_string()))
     }
 
-    // TODO: Versioning
     /// Validate Instant Asset Lock Proof structure
     #[cfg(feature = "validation")]
     pub fn validate_structure(
         &self,
         platform_version: &PlatformVersion,
     ) -> Result<SimpleConsensusValidationResult, ProtocolError> {
-        let mut result = SimpleConsensusValidationResult::default();
-
-        let transaction_id = self.transaction().txid();
-        if self.instant_lock().txid != transaction_id {
-            result.add_error(IdentityAssetLockProofLockedTransactionMismatchError::new(
-                self.instant_lock().txid,
-                transaction_id,
-            ));
-
-            return Ok(result);
-        }
-
-        let validate_transaction_result = validate_asset_lock_transaction_structure(
-            self.transaction(),
-            self.output_index(),
-            platform_version,
-        )?;
-
-        if !validate_transaction_result.is_valid() {
-            result.merge(validate_transaction_result);
+        match platform_version
+            .dpp
+            .state_transitions
+            .identities
+            .asset_locks
+            .validate_instant_asset_lock_proof_structure
+        {
+            0 => methods::validate_structure::validate_instant_asset_lock_proof_structure_v0(
+                self,
+                platform_version,
+            ),
+            version => Err(ProtocolError::UnknownVersionMismatch {
+                method: "validate_instant_asset_lock_proof_structure".to_string(),
+                known_versions: vec![0],
+                received: version,
+            }),
         }
-
-        Ok(result)
     }
 }
 

packages/rs-dpp/src/identity/state_transition/asset_lock_proof/instant/methods/mod.rs

@@ -0,0 +1 @@
+pub mod validate_structure;

packages/rs-dpp/src/identity/state_transition/asset_lock_proof/instant/methods/validate_structure/mod.rs

@@ -0,0 +1,3 @@
+mod v0;
+
+pub use v0::validate_instant_asset_lock_proof_structure_v0;

packages/rs-dpp/src/identity/state_transition/asset_lock_proof/instant/methods/validate_structure/v0/mod.rs

@@ -0,0 +1,35 @@
+use platform_version::version::PlatformVersion;
+use crate::consensus::basic::identity::IdentityAssetLockProofLockedTransactionMismatchError;
+use crate::identity::state_transition::asset_lock_proof::InstantAssetLockProof;
+use crate::identity::state_transition::asset_lock_proof::validate_asset_lock_transaction_structure::validate_asset_lock_transaction_structure;
+use crate::ProtocolError;
+use crate::validation::SimpleConsensusValidationResult;
+
+pub(in crate::identity::state_transition::asset_lock_proof::instant) fn validate_instant_asset_lock_proof_structure_v0(
+    proof: &InstantAssetLockProof,
+    platform_version: &PlatformVersion,
+) -> Result<SimpleConsensusValidationResult, ProtocolError> {
+    let mut result = SimpleConsensusValidationResult::default();
+
+    let transaction_id = proof.transaction().txid();
+    if proof.instant_lock().txid != transaction_id {
+        result.add_error(IdentityAssetLockProofLockedTransactionMismatchError::new(
+            proof.instant_lock().txid,
+            transaction_id,
+        ));
+
+        return Ok(result);
+    }
+
+    let validate_transaction_result = validate_asset_lock_transaction_structure(
+        proof.transaction(),
+        proof.output_index(),
+        platform_version,
+    )?;
+
+    if !validate_transaction_result.is_valid() {
+        result.merge(validate_transaction_result);
+    }
+
+    Ok(result)
+}

packages/rs-dpp/src/identity/state_transition/asset_lock_proof/instant/mod.rs

@@ -1,3 +1,4 @@
 pub use instant_asset_lock_proof::*;
 
 mod instant_asset_lock_proof;
+mod methods;

packages/rs-platform-version/src/version/dpp_versions.rs

@@ -28,6 +28,7 @@ pub struct IdentityTransitionVersions {
 #[derive(Clone, Debug, Default)]
 pub struct IdentityTransitionAssetLockVersions {
     pub validate_asset_lock_transaction_structure: FeatureVersion,
+    pub validate_instant_asset_lock_proof_structure: FeatureVersion,
 }
 
 #[derive(Clone, Debug, Default)]

packages/rs-platform-version/src/version/mocks/v2_test.rs

@@ -825,6 +825,7 @@ pub(crate) const TEST_PLATFORM_V2: PlatformVersion = PlatformVersion {
             identities: IdentityTransitionVersions {
                 asset_locks: IdentityTransitionAssetLockVersions {
                     validate_asset_lock_transaction_structure: 0,
+                    validate_instant_asset_lock_proof_structure: 0,
                 },
             },
         },

packages/rs-platform-version/src/version/mocks/v3_test.rs

@@ -825,6 +825,7 @@ pub(crate) const TEST_PLATFORM_V3: PlatformVersion = PlatformVersion {
             identities: IdentityTransitionVersions {
                 asset_locks: IdentityTransitionAssetLockVersions {
                     validate_asset_lock_transaction_structure: 0,
+                    validate_instant_asset_lock_proof_structure: 0,
                 },
             },
         },

packages/rs-platform-version/src/version/v1.rs

@@ -822,6 +822,7 @@ pub(super) const PLATFORM_V1: PlatformVersion = PlatformVersion {
             identities: IdentityTransitionVersions {
                 asset_locks: IdentityTransitionAssetLockVersions {
                     validate_asset_lock_transaction_structure: 0,
+                    validate_instant_asset_lock_proof_structure: 0,
                 },
             },
         },