chore: make delete_lock for locked notarization optional

notarization-move/Move.lock

@@ -29,9 +29,9 @@ flavor = "iota"
 [env]
 
 [env.localnet]
-chain-id = "c7a0abbd"
-original-published-id = "0x7fab7adeb06a0087b65cd6712e270d338d39f002f8abfb3d252f88c843b61070"
-latest-published-id = "0x7fab7adeb06a0087b65cd6712e270d338d39f002f8abfb3d252f88c843b61070"
+chain-id = "002d6fb7"
+original-published-id = "0x760def1fd86d216536bb3f8809baed9e075a73c428aeb776e4d47ad88e9fc6b4"
+latest-published-id = "0x760def1fd86d216536bb3f8809baed9e075a73c428aeb776e4d47ad88e9fc6b4"
 published-version = "1"
 
 [env.devnet]

notarization-move/sources/dynamic_notarization.move

@@ -31,7 +31,7 @@ public fun new<D: store + drop + copy>(
     state: notarization::State<D>,
     immutable_description: Option<String>,
     updatable_metadata: Option<String>,
-    transfer_lock: Option<TimeLock>,
+    transfer_lock: TimeLock,
     clock: &Clock,
     ctx: &mut TxContext,
 ): notarization::Notarization<D> {
@@ -50,7 +50,7 @@ public fun create<D: store + drop + copy>(
     state: notarization::State<D>,
     immutable_description: Option<String>,
     updatable_metadata: Option<String>,
-    transfer_lock: Option<TimeLock>,
+    transfer_lock: TimeLock,
     clock: &Clock,
     ctx: &mut TxContext,
 ) {

notarization-move/sources/notarization.move

@@ -186,14 +186,16 @@ public(package) fun new_dynamic_notarization<D: store + drop + copy>(
     state: State<D>,
     immutable_description: Option<String>,
     updatable_metadata: Option<String>,
-    transfer_lock: Option<TimeLock>,
+    transfer_lock: TimeLock,
     clock: &Clock,
     ctx: &mut TxContext,
 ): Notarization<D> {
-    let locking = option::map!(
-        transfer_lock,
-        |transfer_lock| new_lock_metadata(timelock::none(), timelock::none(), transfer_lock),
-    );
+    let locking = if (timelock::is_none(&transfer_lock)) {
+        timelock::destroy(transfer_lock, clock);
+        option::none()
+    } else {
+        option::some(new_lock_metadata(timelock::none(), timelock::none(), transfer_lock))
+    };
 
     let immutable_metadata = ImmutableMetadata {
         created_at: clock::timestamp_ms(clock),

notarization-move/tests/dynamic_notarization_tests.move

@@ -30,7 +30,7 @@ public fun test_create_dynamic_notarization_with_string_data() {
         state,
         std::option::some(string::utf8(b"Test Description")),
         std::option::some(string::utf8(b"Test Updatable Metadata")),
-        std::option::none(),
+        timelock::none(),
         &clock,
         ctx,
     );
@@ -84,7 +84,7 @@ public fun test_create_dynamic_notarization_with_vector_data() {
         state,
         std::option::some(string::utf8(b"Test Description")),
         std::option::some(string::utf8(b"Test Updatable Metadata")),
-        std::option::none(),
+        timelock::none(),
         &clock,
         ctx,
     );
@@ -139,7 +139,7 @@ public fun test_create_dynamic_notarization_with_transfer_lock() {
         state,
         std::option::some(string::utf8(b"Test Description")),
         std::option::some(string::utf8(b"Test Updatable Metadata")),
-        std::option::some(transfer_lock),
+        transfer_lock,
         &clock,
         ctx,
     );
@@ -183,7 +183,7 @@ public fun test_transfer_dynamic_notarization() {
             state,
             std::option::none(),
             std::option::none(),
-            std::option::none(),
+            timelock::none(),
             &clock,
             scenario.ctx(),
         );
@@ -242,7 +242,7 @@ public fun test_transfer_locked_dynamic_notarization() {
             state,
             std::option::none(),
             std::option::none(),
-            std::option::some(transfer_lock),
+            transfer_lock,
             &clock,
             scenario.ctx(),
         );
@@ -285,7 +285,7 @@ public fun test_update_dynamic_notarization() {
         state,
         std::option::none(),
         std::option::none(),
-        std::option::none(),
+        timelock::none(),
         &clock,
         ctx,
     );
@@ -344,7 +344,7 @@ public fun test_dynamic_notarization_with_until_destroyed_lock() {
         state,
         std::option::none(),
         std::option::none(),
-        std::option::some(transfer_lock),
+        transfer_lock,
         &clock,
         ctx,
     );
@@ -368,7 +368,7 @@ public fun test_dynamic_notarization_with_until_destroyed_lock() {
     scenario.end();
 }
 
-#[test, expected_failure(abort_code = notarization::EDynamicNotarizationInvariants)]
+#[test]
 public fun test_dynamic_notarization_with_none_lock() {
     let mut scenario = ts::begin(ADMIN_ADDRESS);
     let ctx = scenario.ctx();
@@ -388,7 +388,7 @@ public fun test_dynamic_notarization_with_none_lock() {
         state,
         std::option::none(),
         std::option::none(),
-        std::option::some(transfer_lock),
+        transfer_lock,
         &clock,
         ctx,
     );
@@ -400,6 +400,7 @@ public fun test_dynamic_notarization_with_none_lock() {
 
     // Verify it's transferable (has none transfer lock)
     assert!(dynamic_notarization::is_transferable(&notarization, &clock), 0);
+    assert!(notarization.lock_metadata().is_none(), 0);
 
     // Clean up
     notarization::destroy(notarization, &clock);

notarization-move/tests/notarization_tests.move

@@ -48,7 +48,7 @@ public fun test_create_notarization_with_complex_object() {
         state,
         std::option::some(string::utf8(b"Test Description")),
         std::option::some(string::utf8(b"Test Updateable Metadata")),
-        std::option::none(),
+        timelock::none(),
         &clock,
         ctx,
     );
@@ -153,7 +153,7 @@ public fun test_state_updates_and_versioning() {
         state,
         std::option::some(string::utf8(b"Test Description")),
         std::option::some(string::utf8(b"Test Updateable Metadata")),
-        std::option::none(),
+        timelock::none(),
         &clock,
         ctx,
     );
@@ -316,7 +316,7 @@ public fun test_method_type_checks() {
         state,
         std::option::none(),
         std::option::none(),
-        std::option::none(),
+        timelock::none(),
         &clock,
         ctx,
     );
@@ -363,7 +363,7 @@ public fun test_is_destroy_allowed() {
         state,
         std::option::none(),
         std::option::none(),
-        std::option::none(),
+        timelock::none(),
         &clock,
         ctx,
     );
@@ -408,7 +408,7 @@ public fun test_method_specific_invariants() {
         state,
         std::option::none(),
         std::option::none(),
-        std::option::none(),
+        timelock::none(),
         &clock,
         ctx,
     );

notarization-rs/src/core/builder.rs

@@ -49,9 +49,6 @@ impl NotarizationBuilder<Locked> {
     }
 
     pub fn finish(self) -> Result<TransactionBuilder<CreateNotarization<Locked>>, Error> {
-        if self.delete_lock.is_none() {
-            return Err(Error::InvalidArgument("Locked needs delete_at()".to_string()));
-        }
         Ok(TransactionBuilder::new(CreateNotarization::new(self)))
     }
 }

notarization-rs/src/core/move_utils.rs

@@ -4,13 +4,11 @@
 use std::str::FromStr;
 
 use iota_interaction::rpc_types::IotaObjectDataOptions;
-use iota_interaction::types::base_types::{ObjectID, ObjectRef, STD_OPTION_MODULE_NAME};
+use iota_interaction::types::base_types::{ObjectID, ObjectRef};
 use iota_interaction::types::programmable_transaction_builder::ProgrammableTransactionBuilder as Ptb;
 use iota_interaction::types::transaction::{Argument, ObjectArg};
-use iota_interaction::types::{
-    IOTA_CLOCK_OBJECT_ID, IOTA_CLOCK_OBJECT_SHARED_VERSION, MOVE_STDLIB_PACKAGE_ID, TypeTag,
-};
-use iota_interaction::{IotaClientTrait, OptionalSync, ident_str};
+use iota_interaction::types::{IOTA_CLOCK_OBJECT_ID, IOTA_CLOCK_OBJECT_SHARED_VERSION, TypeTag};
+use iota_interaction::{IotaClientTrait, OptionalSync};
 use product_common::core_client::CoreClientReadOnly;
 use serde::Serialize;
 
@@ -26,32 +24,6 @@ pub(crate) fn get_clock_ref(ptb: &mut Ptb) -> Argument {
     .expect("network has a singleton clock instantiated")
 }
 
-pub(crate) fn option_to_move_with_tag(
-    option: Option<Argument>,
-    tag: TypeTag,
-    ptb: &mut Ptb,
-) -> Result<Argument, Error> {
-    let arg = if let Some(t) = option {
-        ptb.programmable_move_call(
-            MOVE_STDLIB_PACKAGE_ID,
-            STD_OPTION_MODULE_NAME.into(),
-            ident_str!("some").into(),
-            vec![tag],
-            vec![t],
-        )
-    } else {
-        ptb.programmable_move_call(
-            MOVE_STDLIB_PACKAGE_ID,
-            STD_OPTION_MODULE_NAME.into(),
-            ident_str!("none").into(),
-            vec![tag],
-            vec![],
-        )
-    };
-
-    Ok(arg)
-}
-
 pub(crate) fn ptb_pure<T>(ptb: &mut Ptb, name: &str, value: T) -> Result<Argument, Error>
 where
     T: Serialize + core::fmt::Debug,

notarization-rs/src/core/notarization.rs

@@ -53,11 +53,9 @@ 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`.
+    /// - 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) => {
@@ -126,7 +124,7 @@ impl<M: Clone> CreateNotarization<M> {
                     state,
                     immutable_description,
                     updatable_metadata,
-                    transfer_lock,
+                    transfer_lock.unwrap_or(TimeLock::None),
                 )
             }
             NotarizationMethod::Locked => {
@@ -136,14 +134,10 @@ impl<M: Clone> CreateNotarization<M> {
                     ));
                 }
 
-                let delete_lock = delete_lock.ok_or_else(|| {
-                    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(),
+                    delete_lock: delete_lock.clone().unwrap_or(TimeLock::None),
                     transfer_lock: TimeLock::UntilDestroyed,
                 });
 
@@ -159,7 +153,7 @@ impl<M: Clone> CreateNotarization<M> {
                     state,
                     immutable_description,
                     updatable_metadata,
-                    delete_lock,
+                    delete_lock.unwrap_or(TimeLock::None),
                 )
             }
         }

notarization-rs/src/core/operations.rs

@@ -8,7 +8,7 @@ use iota_interaction::types::Identifier;
 use iota_interaction::types::base_types::{IotaAddress, ObjectID};
 use iota_interaction::types::programmable_transaction_builder::ProgrammableTransactionBuilder;
 use iota_interaction::types::transaction::{Argument, ObjectArg, ProgrammableTransaction};
-use iota_interaction::{MoveType, OptionalSync, ident_str};
+use iota_interaction::{OptionalSync, ident_str};
 use product_common::core_client::CoreClientReadOnly;
 
 use super::move_utils;
@@ -121,7 +121,7 @@ pub trait NotarizationOperations {
         state: State,
         immutable_description: Option<String>,
         updatable_metadata: Option<String>,
-        transfer_lock: Option<TimeLock>,
+        transfer_lock: TimeLock,
     ) -> Result<ProgrammableTransaction, Error> {
         let mut ptb = ProgrammableTransactionBuilder::new();
 
@@ -130,11 +130,7 @@ pub trait NotarizationOperations {
         let state_arg = state.into_ptb(&mut ptb, package_id)?;
         let immutable_description = move_utils::ptb_pure(&mut ptb, "immutable_description", immutable_description)?;
         let updatable_metadata = move_utils::ptb_pure(&mut ptb, "updatable_metadata", updatable_metadata)?;
-        let transfer_lock = transfer_lock
-            .map(|lock| lock.to_ptb(&mut ptb, package_id))
-            .transpose()?;
-        let transfer_lock =
-            move_utils::option_to_move_with_tag(transfer_lock, TimeLock::move_type(package_id), &mut ptb)?;
+        let transfer_lock = transfer_lock.to_ptb(&mut ptb, package_id)?;
 
         ptb.programmable_move_call(
             package_id,