Merge pull request #47 from iotaledger/feat/add-invariants-checking

Feat/add invariants checking

Author: itsyaasir

notarization-move/Move.lock

@@ -30,8 +30,8 @@ flavor = "iota"
 
 [env.localnet]
 chain-id = "c7a0abbd"
-original-published-id = "0x3cb59fb212b83ee62dd6258025fcbe0332ca156ceb8d5d85fe9b9a6cf066c4ab"
-latest-published-id = "0x3cb59fb212b83ee62dd6258025fcbe0332ca156ceb8d5d85fe9b9a6cf066c4ab"
+original-published-id = "0x7fab7adeb06a0087b65cd6712e270d338d39f002f8abfb3d252f88c843b61070"
+latest-published-id = "0x7fab7adeb06a0087b65cd6712e270d338d39f002f8abfb3d252f88c843b61070"
 published-version = "1"
 
 [env.devnet]

notarization-rs/src/core/notarization.rs

@@ -20,6 +20,7 @@ use super::event::{DynamicNotarizationCreated, Event, LockedNotarizationCreated}
 use super::metadata::ImmutableMetadata;
 use super::operations::{NotarizationImpl, NotarizationOperations};
 use super::state::State;
+use super::timelock::{LockMetadata, TimeLock};
 use crate::error::Error;
 use crate::package::notarization_package_id;
 
@@ -50,6 +51,38 @@ impl<M: Clone> CreateNotarization<M> {
         }
     }
 
+    /// Indicates if the invariants for `NotarizationMethod::Dynamic` are satisfied:
+    ///
+    /// - Dynamic notarization can only have transfer locking or no
+    ///   `immutable_metadata.locking`.
+    ///   If `immutable_metadata.locking` exists, all locks except `transfer_lock`
+    ///   must be `TimeLock::None`
+    ///   and the `transfer_lock` must not be `TimeLock::None`.
+    fn are_dynamic_notarization_invariants_ok(locking: &Option<LockMetadata>) -> bool {
+        match locking {
+            Some(lock_metadata) => {
+                lock_metadata.delete_lock == TimeLock::None
+                    && lock_metadata.update_lock == TimeLock::None
+                    && lock_metadata.transfer_lock != TimeLock::None
+            }
+            None => true,
+        }
+    }
+
+    /// Indicates if the invariants for `NotarizationMethod::Locked` are satisfied:
+    ///
+    /// - `locking` must exist.
+    /// - `update_lock` and `transfer_lock` must be `TimeLock::UntilDestroyed`.
+    fn are_locked_notarization_invariants_ok(locking: &Option<LockMetadata>) -> bool {
+        match locking {
+            Some(lock_metadata) => {
+                lock_metadata.transfer_lock == TimeLock::UntilDestroyed
+                    && lock_metadata.update_lock == TimeLock::UntilDestroyed
+            }
+            None => false,
+        }
+    }
+
     /// Makes a [`ProgrammableTransaction`] for the [`CreateNotarization`] instance.
     async fn make_ptb(&self, client: &impl CoreClientReadOnly) -> Result<ProgrammableTransaction, Error> {
         let NotarizationBuilder {
@@ -74,6 +107,20 @@ impl<M: Clone> CreateNotarization<M> {
                     ));
                 }
 
+                // Construct the locking metadata for dynamic notarization
+                let locking = transfer_lock.as_ref().map(|t_lock| LockMetadata {
+                    update_lock: TimeLock::None,
+                    delete_lock: TimeLock::None,
+                    transfer_lock: t_lock.clone(),
+                });
+
+                // Check invariants
+                if !Self::are_dynamic_notarization_invariants_ok(&locking) {
+                    return Err(Error::InvalidArgument(
+                        "Dynamic notarization invariants are not satisfied".to_string(),
+                    ));
+                }
+
                 NotarizationImpl::new_dynamic(
                     package_id,
                     state,
@@ -93,6 +140,20 @@ impl<M: Clone> CreateNotarization<M> {
                     Error::InvalidArgument("Delete lock is required for locked notarizations".to_string())
                 })?;
 
+                // Construct the locking metadata for locked notarization
+                let locking = Some(LockMetadata {
+                    update_lock: TimeLock::UntilDestroyed,
+                    delete_lock: delete_lock.clone(),
+                    transfer_lock: TimeLock::UntilDestroyed,
+                });
+
+                // Check invariants
+                if !Self::are_locked_notarization_invariants_ok(&locking) {
+                    return Err(Error::InvalidArgument(
+                        "Locked notarization invariants are not satisfied".to_string(),
+                    ));
+                }
+
                 NotarizationImpl::new_locked(
                     package_id,
                     state,
@@ -186,3 +247,42 @@ pub(crate) async fn get_object_ref_by_id_with_bcs<T: DeserializeOwned>(
 
     Ok(notarization)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_dynamic_notarization_invariants() {
+        let are_dynamic_notarization_invariants_ok = CreateNotarization::<()>::are_dynamic_notarization_invariants_ok;
+
+        assert!(are_dynamic_notarization_invariants_ok(&None));
+        assert!(are_dynamic_notarization_invariants_ok(&Some(LockMetadata {
+            update_lock: TimeLock::None,
+            delete_lock: TimeLock::None,
+            transfer_lock: TimeLock::UntilDestroyed,
+        })));
+        assert!(!are_dynamic_notarization_invariants_ok(&Some(LockMetadata {
+            update_lock: TimeLock::None,
+            delete_lock: TimeLock::None,
+            transfer_lock: TimeLock::None,
+        })));
+    }
+
+    #[test]
+    fn test_locked_notarization_invariants() {
+        let are_locked_notarization_invariants_ok = CreateNotarization::<()>::are_locked_notarization_invariants_ok;
+
+        assert!(!are_locked_notarization_invariants_ok(&None));
+        assert!(are_locked_notarization_invariants_ok(&Some(LockMetadata {
+            update_lock: TimeLock::UntilDestroyed,
+            delete_lock: TimeLock::UntilDestroyed,
+            transfer_lock: TimeLock::UntilDestroyed,
+        })));
+        assert!(!are_locked_notarization_invariants_ok(&Some(LockMetadata {
+            update_lock: TimeLock::UntilDestroyed,
+            delete_lock: TimeLock::UntilDestroyed,
+            transfer_lock: TimeLock::None,
+        })));
+    }
+}