Add manual deser for Data

Author: itsyaasir

notarization-move/Move.lock

@@ -22,16 +22,16 @@ id = "MoveStdlib"
 source = { git = "https://github.com/iotaledger/iota.git", rev = "80fc853da5811f842be7bf749d6a981a17c9e565", subdir = "crates/iota-framework/packages/move-stdlib" }
 
 [move.toolchain-version]
-compiler-version = "0.11.6-rc"
+compiler-version = "1.1.0"
 edition = "2024.beta"
 flavor = "iota"
 
 [env]
 
 [env.localnet]
-chain-id = "2263b3a8"
-original-published-id = "0xfe2e54aae674420034f157607af3a74aece5df37c600e25de4a9db9e1fc648ae"
-latest-published-id = "0xfe2e54aae674420034f157607af3a74aece5df37c600e25de4a9db9e1fc648ae"
+chain-id = "11d8ffd3"
+original-published-id = "0xe44dc179140a174935fd79f7ac946f796cdfe02e74461624e983a31eb9765f6c"
+latest-published-id = "0xe44dc179140a174935fd79f7ac946f796cdfe02e74461624e983a31eb9765f6c"
 published-version = "1"
 
 [env.devnet]

notarization-rs/Cargo.toml

@@ -19,6 +19,7 @@ phf.workspace = true
 product_common = { workspace = true, default-features = false, features = [
     "transaction",
 ] }
+serde-value = "0.7.0"
 serde.workspace = true
 serde_json.workspace = true
 thiserror.workspace = true

notarization-rs/src/client/read_only.rs

@@ -419,8 +419,6 @@ impl NotarizationClientReadOnly {
             .await
             .map_err(|err| Error::UnexpectedApiResponse(format!("Failed to inspect transaction block: {err}")))?;
 
-        println!("inspection_result: {:?}", inspection_result);
-
         let execution_results = inspection_result
             .results
             .ok_or_else(|| Error::UnexpectedApiResponse("DevInspectResults missing 'results' field".to_string()))?;

notarization-rs/src/core/notarization.rs

@@ -31,8 +31,7 @@ use iota_interaction::IotaClientTrait;
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
 pub struct OnChainNotarization {
     pub id: UID,
-    // TODO: remove this field and use the state field instead
-    pub state: State<String>,
+    pub state: State,
     pub immutable_metadata: ImmutableMetadata,
     pub updateable_metadata: Option<String>,
     pub last_state_change_at: u64,
@@ -143,8 +142,6 @@ impl<M: Clone + OptionalSend + OptionalSync> Transaction for CreateNotarization<
             .first()
             .ok_or_else(|| Error::TransactionUnexpectedResponse("events should be provided".to_string()))?;
 
-        println!("data: {:?}", data);
-
         let notarization_id = match method {
             NotarizationMethod::Dynamic => {
                 let event: Event<DynamicNotarizationCreated> = serde_json::from_value(data.parsed_json.clone())

notarization-rs/src/core/state.rs

@@ -1,6 +1,7 @@
 // Copyright 2020-2025 IOTA Stiftung
 // SPDX-License-Identifier: Apache-2.0
 
+use core::fmt;
 use std::str::FromStr;
 
 use async_trait::async_trait;
@@ -12,7 +13,7 @@ use iota_interaction::types::{TypeTag, MOVE_STDLIB_PACKAGE_ID};
 use iota_interaction::{ident_str, MoveType, OptionalSync};
 use product_common::core_client::CoreClientReadOnly;
 use product_common::transaction::transaction_builder::Transaction;
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize};
 use tokio::sync::OnceCell;
 
 use super::move_utils;
@@ -28,12 +29,27 @@ pub struct State<T = Data> {
     pub metadata: Option<String>,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Serialize, PartialEq)]
 pub enum Data {
     Bytes(Vec<u8>),
     Text(String),
 }
 
+impl<'de> Deserialize<'de> for Data {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let raw_bytes = Vec::<u8>::deserialize(deserializer)?;
+
+        if let Ok(text) = String::from_utf8(raw_bytes.clone()) {
+            return Ok(Data::Text(text));
+        }
+
+        Ok(Data::Bytes(raw_bytes))
+    }
+}
+
 impl Data {
     pub(crate) fn tag(&self) -> TypeTag {
         match self {
@@ -42,6 +58,20 @@ impl Data {
                 .expect("should be valid type tag"),
         }
     }
+
+    pub fn as_bytes(self) -> Result<Vec<u8>, Error> {
+        match self {
+            Data::Bytes(data) => Ok(data),
+            Data::Text(_) => Err(Error::GenericError("Data is not a vector".to_string())),
+        }
+    }
+
+    pub fn as_text(self) -> Result<String, Error> {
+        match self {
+            Data::Bytes(_) => Err(Error::GenericError("Data is not a string".to_string())),
+            Data::Text(data) => Ok(data),
+        }
+    }
 }
 
 impl State {

notarization-rs/tests/e2e/dynamic_notarization.rs

@@ -13,6 +13,7 @@ use notarization::core::notarization::OnChainNotarization;
 use notarization::core::state::{Data, State};
 use notarization::core::timelock::TimeLock;
 use notarization::core::NotarizationMethod;
+use product_common::core_client::CoreClientReadOnly;
 
 #[tokio::test]
 async fn create_simple_dynamic_notarization_works() -> anyhow::Result<()> {
@@ -27,8 +28,6 @@ async fn create_simple_dynamic_notarization_works() -> anyhow::Result<()> {
         .await?
         .output;
 
-    println!("onchain_notarization: {:?}", onchain_notarization);
-
     assert_eq!(
         onchain_notarization.immutable_metadata.description,
         Some("Test Notarization".to_string())
@@ -145,7 +144,7 @@ async fn test_update_state_dynamic_notarization() -> anyhow::Result<()> {
         .id;
 
     let new_state = State::from_string("updated_state".to_string(), Some("state_metadata".to_string()));
-    
+
     let update_result = test_client
         .update_state(new_state.clone(), *notarization_id.object_id())
         .build_and_execute(&mut test_client)
@@ -154,7 +153,7 @@ async fn test_update_state_dynamic_notarization() -> anyhow::Result<()> {
     assert!(update_result.is_ok(), "State update should succeed");
 
     let retrieved_state = test_client.state(*notarization_id.object_id()).await?;
-    assert_eq!(retrieved_state.data.as_string()?, "updated_state");
+    assert_eq!(retrieved_state.data.as_text()?, "updated_state");
     assert_eq!(retrieved_state.metadata, Some("state_metadata".to_string()));
 
     let version_count = test_client.state_version_count(*notarization_id.object_id()).await?;
@@ -179,7 +178,7 @@ async fn test_update_metadata_dynamic_notarization() -> anyhow::Result<()> {
         .id;
 
     let new_metadata = Some("updated_metadata".to_string());
-    
+
     let update_result = test_client
         .update_metadata(new_metadata.clone(), *notarization_id.object_id())
         .build_and_execute(&mut test_client)
@@ -215,7 +214,10 @@ async fn test_destroy_dynamic_notarization_no_locks() -> anyhow::Result<()> {
         .build_and_execute(&mut test_client)
         .await;
 
-    assert!(destroy_result.is_ok(), "Destroy should succeed for unlocked notarization");
+    assert!(
+        destroy_result.is_ok(),
+        "Destroy should succeed for unlocked notarization"
+    );
 
     Ok(())
 }
@@ -254,10 +256,13 @@ async fn test_read_only_methods_dynamic_notarization() -> anyhow::Result<()> {
 
     let description = "Test Description".to_string();
     let updateable_metadata = "Test Metadata".to_string();
-    
+
     let notarization_id = test_client
         .create_dynamic_notarization()
-        .with_state(State::from_string("test_state".to_string(), Some("state_meta".to_string())))
+        .with_state(State::from_string(
+            "test_state".to_string(),
+            Some("state_meta".to_string()),
+        ))
         .with_immutable_description(description.clone())
         .with_updateable_metadata(updateable_metadata.clone())
         .finish()
@@ -273,7 +278,7 @@ async fn test_read_only_methods_dynamic_notarization() -> anyhow::Result<()> {
     assert_eq!(retrieved_metadata, Some(updateable_metadata));
 
     let state = test_client.state(*notarization_id.object_id()).await?;
-    assert_eq!(state.data.as_string()?, "test_state");
+    assert_eq!(state.data.as_text()?, "test_state");
     assert_eq!(state.metadata, Some("state_meta".to_string()));
 
     let created_at = test_client.created_at_ts(*notarization_id.object_id()).await?;
@@ -317,14 +322,38 @@ async fn test_lock_checking_methods() -> anyhow::Result<()> {
         .output
         .id;
 
-    assert!(test_client.is_transfer_locked(*locked_notarization_id.object_id()).await?);
-    assert!(!test_client.is_transfer_locked(*unlocked_notarization_id.object_id()).await?);
+    assert!(
+        test_client
+            .is_transfer_locked(*locked_notarization_id.object_id())
+            .await?
+    );
+    assert!(
+        !test_client
+            .is_transfer_locked(*unlocked_notarization_id.object_id())
+            .await?
+    );
 
-    assert!(!test_client.is_update_locked(*locked_notarization_id.object_id()).await?);
-    assert!(!test_client.is_update_locked(*unlocked_notarization_id.object_id()).await?);
+    assert!(
+        !test_client
+            .is_update_locked(*locked_notarization_id.object_id())
+            .await?
+    );
+    assert!(
+        !test_client
+            .is_update_locked(*unlocked_notarization_id.object_id())
+            .await?
+    );
 
-    assert!(!test_client.is_destroy_locked(*locked_notarization_id.object_id()).await?);
-    assert!(!test_client.is_destroy_locked(*unlocked_notarization_id.object_id()).await?);
+    assert!(
+        !test_client
+            .is_destroy_locked(*locked_notarization_id.object_id())
+            .await?
+    );
+    assert!(
+        !test_client
+            .is_destroy_locked(*unlocked_notarization_id.object_id())
+            .await?
+    );
 
     let lock_metadata_locked = test_client.lock_metadata(*locked_notarization_id.object_id()).await?;
     assert!(lock_metadata_locked.is_some());
@@ -350,7 +379,7 @@ async fn test_multiple_state_updates() -> anyhow::Result<()> {
 
     for i in 1..=3 {
         let new_state = State::from_string(format!("state_v{}", i), Some(format!("metadata_{}", i)));
-        
+
         test_client
             .update_state(new_state, *notarization_id.object_id())
             .build_and_execute(&mut test_client)
@@ -360,7 +389,7 @@ async fn test_multiple_state_updates() -> anyhow::Result<()> {
         assert_eq!(version_count, i as u64);
 
         let state = test_client.state(*notarization_id.object_id()).await?;
-        assert_eq!(state.data.as_string()?, format!("state_v{}", i));
+        assert_eq!(state.data.as_text()?, format!("state_v{}", i));
         assert_eq!(state.metadata, Some(format!("metadata_{}", i)));
     }
 
@@ -386,7 +415,7 @@ async fn test_bytes_state_operations() -> anyhow::Result<()> {
 
     let updated_data = vec![10, 20, 30];
     let new_state = State::from_bytes(updated_data.clone(), Some("bytes_metadata".to_string()));
-    
+
     test_client
         .update_state(new_state, *notarization_id.object_id())
         .build_and_execute(&mut test_client)