Refactor notarization examples and update scripts

Author: itsyaasir

examples/01_create_locked_notarization.rs

@@ -5,7 +5,6 @@ use std::time::{SystemTime, UNIX_EPOCH};
 
 use anyhow::Result;
 use examples::get_funded_client;
-
 use notarization::core::state::State;
 use notarization::core::timelock::TimeLock;
 use notarization::core::NotarizationMethod;

examples/02_create_dynamic_notarization.rs

@@ -4,10 +4,10 @@
 use std::time::{SystemTime, UNIX_EPOCH};
 
 use anyhow::Result;
+use examples::get_funded_client;
 use notarization::core::state::State;
 use notarization::core::timelock::TimeLock;
 use notarization::core::NotarizationMethod;
-use examples::get_funded_client;
 
 #[tokio::main]
 async fn main() -> Result<()> {
@@ -44,10 +44,7 @@ async fn main() -> Result<()> {
     // Create a dynamic notarization with transfer lock
     let locked_transfer_notarization = notarization_client
         .create_dynamic_notarization()
-        .with_state(State::from_string(
-            "Transfer-locked content".to_string(),
-            None,
-        ))
+        .with_state(State::from_string("Transfer-locked content".to_string(), None))
         .with_immutable_description("Transfer-locked document".to_string())
         .with_transfer_lock(TimeLock::UnlockAt(unlock_at as u32))
         .finish()
@@ -74,4 +71,4 @@ async fn main() -> Result<()> {
     println!("📝 State and metadata can be modified over time");
 
     Ok(())
-}
+}

examples/03_update_dynamic_notarization.rs

@@ -0,0 +1,70 @@
+// Copyright 2020-2025 IOTA Stiftung
+// SPDX-License-Identifier: Apache-2.0
+
+use anyhow::Result;
+use examples::get_funded_client;
+use notarization::core::state::State;
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    println!("Demonstrating update on dynamic notarization");
+
+    let notarization_client = get_funded_client().await?;
+
+    println!("Creating a dynamic notarization...");
+
+    // Create a dynamic notarization
+    let dynamic_notarization_id = notarization_client
+        .create_dynamic_notarization()
+        .with_state(State::from_string(
+            "Original content".to_string(),
+            Some("Original metadata".to_string()),
+        ))
+        .with_immutable_description("Dynamic document for update test".to_string())
+        .with_updateable_metadata("Initial updateable metadata".to_string())
+        .finish()
+        .build_and_execute(&notarization_client)
+        .await?
+        .output
+        .id;
+
+    println!("✅ Dynamic notarization created with ID: {:?}", dynamic_notarization_id);
+
+    let current_state = notarization_client.state(*dynamic_notarization_id.object_id()).await?;
+    println!("Initial state: {}", current_state.data.as_text()?);
+    println!("Initial state metadata: {:?}", current_state.metadata);
+
+    println!("\n🔄 Updating state on dynamic notarization...");
+    let new_state = State::from_string("Updated content".to_string(), Some("New metadata".to_string()));
+
+    let state_update_result = notarization_client
+        .update_state(new_state, *dynamic_notarization_id.object_id())
+        .build_and_execute(&notarization_client)
+        .await;
+
+    match state_update_result {
+        Ok(_) => println!("✅ State update succeeded"),
+        Err(e) => println!("❌ State update failed - {}", e),
+    }
+
+    println!("\n📝 Updating metadata on dynamic notarization...");
+    let new_metadata = Some("Updated metadata".to_string());
+
+    let metadata_update_result = notarization_client
+        .update_metadata(new_metadata, *dynamic_notarization_id.object_id())
+        .build_and_execute(&notarization_client)
+        .await;
+
+    match metadata_update_result {
+        Ok(_) => println!("✅ Metadata update succeeded"),
+        Err(e) => println!("❌ Metadata update failed - {}", e),
+    }
+
+    let current_state = notarization_client.state(*dynamic_notarization_id.object_id()).await?;
+    println!("Updated state: {}", current_state.data.as_text()?);
+    println!("Updated state metadata: {:?}", current_state.metadata);
+
+    println!("\n🔒 Dynamic notarizations are mutable - state and metadata can be changed");
+
+    Ok(())
+}

examples/03_update_locked_notarization.rs

@@ -75,38 +75,16 @@ async fn main() -> Result<()> {
         assert_eq!(version_count, i as u64);
     }
 
-    // Demonstrate working with binary data
-    println!("\n🔢 Demonstrating binary state updates...");
-
-    let binary_data = vec![0x48, 0x65, 0x6C, 0x6C, 0x6F]; // "Hello" in bytes
-    let binary_state = State::from_bytes(binary_data.clone(), Some("Binary data example".to_string()));
-
-    // Update with binary state
-    notarization_client
-        .update_state(binary_state, *notarization_id.object_id())
-        .build_and_execute(&notarization_client)
-        .await?;
-
-    println!("✅ Binary state update completed");
-
-    // Retrieve and verify binary state
-    let binary_retrieved = notarization_client.state(*notarization_id.object_id()).await?;
-
-    let retrieved_bytes = binary_retrieved.data.as_bytes()?;
-    println!("Retrieved binary data: {:?}", retrieved_bytes);
-    println!("As text: {}", String::from_utf8_lossy(&retrieved_bytes));
-
-    // Verify binary data matches
-    assert_eq!(retrieved_bytes, binary_data);
-
     // Show final version count
     let final_version_count = notarization_client
         .state_version_count(*notarization_id.object_id())
         .await?;
 
+    let final_state = notarization_client.state(*notarization_id.object_id()).await?;
+
     println!("\n📊 Final Statistics:");
     println!("Total updates performed: {}", final_version_count);
-    println!("Final metadata: {:?}", binary_retrieved.metadata);
+    println!("Final metadata: {:?}", final_state.metadata);
 
     // Get last state change timestamp
     let last_change = notarization_client
@@ -118,7 +96,7 @@ async fn main() -> Result<()> {
     println!("\n🎯 Key Points:");
     println!("✓ Dynamic notarizations support state updates");
     println!("✓ Each update increments the version count");
-    println!("✓ Both text and binary data are supported");
+    println!("✓ Both text and bytes data are supported");
     println!("✓ State metadata can be updated alongside content");
     println!("✓ Timestamps track when changes were made");
 

examples/05_update_state.rs

@@ -37,8 +37,8 @@ path = "02_create_dynamic_notarization.rs"
 name = "02_create_dynamic_notarization"
 
 [[example]]
-path = "03_update_locked_notarization.rs"
-name = "03_update_locked_notarization"
+path = "03_update_dynamic_notarization.rs"
+name = "03_update_dynamic_notarization"
 
 [[example]]
 path = "04_destroy_notarization.rs"

examples/Cargo.toml

@@ -0,0 +1,40 @@
+#!/bin/bash
+
+# Script to run all notarization examples
+# Usage: ./run.sh
+# Make sure to set NOTARIZATION_PKG_ID environment variable
+
+if [ -z "$IOTA_NOTARIZATION_PKG_ID" ]; then
+    echo "Error: NOTARIZATION_PKG_ID environment variable is not set"
+    echo "Usage: NOTARIZATION_PKG_ID=0x... ./run.sh"
+    exit 1
+fi
+
+echo "Running all notarization examples..."
+echo "Package ID: $IOTA_NOTARIZATION_PKG_ID"
+echo "================================"
+
+examples=(
+    "01_create_locked_notarization"
+    "02_create_dynamic_notarization"
+    "03_update_dynamic_notarization"
+    "04_destroy_notarization"
+    "05_update_state"
+    "06_update_metadata"
+    "07_transfer_dynamic_notarization"
+    "08_access_read_only_methods"
+)
+
+for example in "${examples[@]}"; do
+    echo ""
+    echo "Running: $example"
+    echo "------------------------"
+    cargo run --release --example "$example"
+    if [ $? -ne 0 ]; then
+        echo "Error: Failed to run $example"
+        exit 1
+    fi
+done
+
+echo ""
+echo "All examples completed successfully!"

examples/run.sh

@@ -29,9 +29,9 @@ flavor = "iota"
 [env]
 
 [env.localnet]
-chain-id = "11d8ffd3"
-original-published-id = "0x1a00d75b8c5cc4086b469afccf3abbdcca55b7e57ac7a1f24d3c0d1f71fe4de4"
-latest-published-id = "0x1a00d75b8c5cc4086b469afccf3abbdcca55b7e57ac7a1f24d3c0d1f71fe4de4"
+chain-id = "f34938a6"
+original-published-id = "0x4d3fb7928aa352e7ad65710fa06a27848f99d428bbc8d99938557f65f7753623"
+latest-published-id = "0x4d3fb7928aa352e7ad65710fa06a27848f99d428bbc8d99938557f65f7753623"
 published-version = "1"
 
 [env.devnet]

notarization-move/Move.lock

@@ -101,7 +101,7 @@ public struct NotarizationDestroyed has copy, drop {
 
 // ===== Constructor Functions =====
 /// Create a new state from a vector<u8> data
-public fun new_state_from_vector(data: vector<u8>, metadata: Option<String>): State<vector<u8>> {
+public fun new_state_from_bytes(data: vector<u8>, metadata: Option<String>): State<vector<u8>> {
     State { data, metadata }
 }
 

notarization-move/sources/notarization.move

@@ -77,7 +77,7 @@ public fun test_create_dynamic_notarization_with_vector_data() {
     vector::push_back(&mut data, 2u8);
     vector::push_back(&mut data, 3u8);
     let metadata = std::option::some(string::utf8(b"Test Metadata"));
-    let state = notarization::new_state_from_vector(data, metadata);
+    let state = notarization::new_state_from_bytes(data, metadata);
 
     // Create a dynamic notarization with no transfer lock
     dynamic_notarization::create(