refactor(sdk): conversion methods

packages/js-evo-sdk/src/dpns/facade.ts

@@ -49,12 +49,12 @@ export class DpnsFacade {
     return w.getDpnsUsername(identityId);
   }
 
-  async usernamesWithProof(query: wasm.DpnsUsernamesQuery): Promise<wasm.DpnsUsernamesProofResponse> {
+  async usernamesWithProof(query: wasm.DpnsUsernamesQuery): Promise<wasm.ProofMetadataResponseTyped<Array<string>>> {
     const w = await this.sdk.getWasmSdkConnected();
     return w.getDpnsUsernamesWithProofInfo(query);
   }
 
-  async usernameWithProof(identityId: wasm.IdentifierLike): Promise<wasm.DpnsUsernameProofResponse> {
+  async usernameWithProof(identityId: wasm.IdentifierLike): Promise<wasm.ProofMetadataResponseTyped<string | null>> {
     const w = await this.sdk.getWasmSdkConnected();
     return w.getDpnsUsernameWithProofInfo(identityId);
   }

packages/js-evo-sdk/src/group/facade.ts

@@ -85,12 +85,12 @@ export class GroupFacade {
     return w.getContestedResourcesWithProofInfo(query);
   }
 
-  async contestedResourceVotersForIdentity(query: wasm.ContestedResourceVotersForIdentityQuery): Promise<string[]> {
+  async contestedResourceVotersForIdentity(query: wasm.ContestedResourceVotersForIdentityQuery): Promise<wasm.Identifier[]> {
     const w = await this.sdk.getWasmSdkConnected();
     return w.getContestedResourceVotersForIdentity(query);
   }
 
-  async contestedResourceVotersForIdentityWithProof(query: wasm.ContestedResourceVotersForIdentityQuery): Promise<wasm.ProofMetadataResponseTyped<string[]>> {
+  async contestedResourceVotersForIdentityWithProof(query: wasm.ContestedResourceVotersForIdentityQuery): Promise<wasm.ProofMetadataResponseTyped<wasm.Identifier[]>> {
     const w = await this.sdk.getWasmSdkConnected();
     return w.getContestedResourceVotersForIdentityWithProofInfo(query);
   }

packages/js-evo-sdk/src/voting/facade.ts

@@ -16,12 +16,12 @@ export class VotingFacade {
     return w.getContestedResourceVoteStateWithProofInfo(query);
   }
 
-  async contestedResourceIdentityVotes(query: wasm.ContestedResourceIdentityVotesQuery): Promise<any[]> {
+  async contestedResourceIdentityVotes(query: wasm.ContestedResourceIdentityVotesQuery): Promise<Map<wasm.Identifier, wasm.ResourceVote>> {
     const w = await this.sdk.getWasmSdkConnected();
     return w.getContestedResourceIdentityVotes(query);
   }
 
-  async contestedResourceIdentityVotesWithProof(query: wasm.ContestedResourceIdentityVotesQuery): Promise<wasm.ProofMetadataResponseTyped<{ votes: Array<any> }>> {
+  async contestedResourceIdentityVotesWithProof(query: wasm.ContestedResourceIdentityVotesQuery): Promise<wasm.ProofMetadataResponseTyped<Map<wasm.Identifier, wasm.ResourceVote>>> {
     const w = await this.sdk.getWasmSdkConnected();
     return w.getContestedResourceIdentityVotesWithProofInfo(query);
   }

packages/rs-dpp/src/document/extended_document/v0/json_conversion.rs

@@ -42,12 +42,13 @@ impl DocumentJsonMethodsV0<'_> for ExtendedDocumentV0 {
         Ok(json)
     }
 
-    fn from_json_value<S>(
+    fn from_json_value<S, E>(
         document_value: JsonValue,
         platform_version: &PlatformVersion,
     ) -> Result<Self, ProtocolError>
     where
-        for<'de> S: Deserialize<'de> + TryInto<Identifier, Error = ProtocolError>,
+        for<'de> S: Deserialize<'de> + TryInto<Identifier, Error = E>,
+        E: Into<ProtocolError>,
     {
         Self::from_platform_value(document_value.into(), platform_version)
     }

packages/rs-dpp/src/document/serialization_traits/json_conversion/mod.rs

@@ -29,19 +29,20 @@ impl DocumentJsonMethodsV0<'_> for Document {
     }
 
     /// Create a document from a JSON value.
-    fn from_json_value<S>(
+    fn from_json_value<S, E>(
         document_value: JsonValue,
         platform_version: &PlatformVersion,
     ) -> Result<Self, ProtocolError>
     where
-        for<'de> S: Deserialize<'de> + TryInto<Identifier, Error = ProtocolError>,
+        for<'de> S: Deserialize<'de> + TryInto<Identifier, Error = E>,
+        E: Into<ProtocolError>,
     {
         match platform_version
             .dpp
             .document_versions
             .document_structure_version
         {
-            0 => Ok(Document::V0(DocumentV0::from_json_value::<S>(
+            0 => Ok(Document::V0(DocumentV0::from_json_value::<S, E>(
                 document_value,
                 platform_version,
             )?)),

packages/rs-dpp/src/document/serialization_traits/json_conversion/v0/mod.rs

@@ -12,11 +12,12 @@ pub trait DocumentJsonMethodsV0<'a>: DocumentPlatformValueMethodsV0<'a> {
         platform_version: &PlatformVersion,
     ) -> Result<JsonValue, ProtocolError>;
     fn to_json(&self, platform_version: &PlatformVersion) -> Result<JsonValue, ProtocolError>;
-    fn from_json_value<S>(
+    fn from_json_value<S, E>(
         document_value: JsonValue,
         platform_version: &PlatformVersion,
     ) -> Result<Self, ProtocolError>
     where
-        for<'de> S: Deserialize<'de> + TryInto<Identifier, Error = ProtocolError>,
+        for<'de> S: Deserialize<'de> + TryInto<Identifier, Error = E>,
+        E: Into<ProtocolError>,
         Self: Sized;
 }

packages/rs-dpp/src/document/v0/json_conversion.rs

@@ -104,24 +104,29 @@ impl DocumentJsonMethodsV0<'_> for DocumentV0 {
             .map(|v| v.try_into().map_err(ProtocolError::ValueError))?
     }
 
-    fn from_json_value<S>(
+    fn from_json_value<S, E>(
         mut document_value: JsonValue,
         _platform_version: &PlatformVersion,
     ) -> Result<Self, ProtocolError>
     where
-        for<'de> S: Deserialize<'de> + TryInto<Identifier, Error = ProtocolError>,
+        for<'de> S: Deserialize<'de> + TryInto<Identifier, Error = E>,
+        E: Into<ProtocolError>,
     {
         let mut document = Self {
             ..Default::default()
         };
 
         if let Ok(value) = document_value.remove(property_names::ID) {
-            let data: S = serde_json::from_value(value)?;
-            document.id = data.try_into()?;
+            if !value.is_null() {
+                let data: S = serde_json::from_value(value)?;
+                document.id = data.try_into().map_err(Into::into)?;
+            }
         }
         if let Ok(value) = document_value.remove(property_names::OWNER_ID) {
-            let data: S = serde_json::from_value(value)?;
-            document.owner_id = data.try_into()?;
+            if !value.is_null() {
+                let data: S = serde_json::from_value(value)?;
+                document.owner_id = data.try_into().map_err(Into::into)?;
+            }
         }
         if let Ok(value) = document_value.remove(property_names::REVISION) {
             document.revision = serde_json::from_value(value)?
@@ -154,8 +159,10 @@ impl DocumentJsonMethodsV0<'_> for DocumentV0 {
             document.transferred_at_core_block_height = serde_json::from_value(value)?;
         }
         if let Ok(value) = document_value.remove(property_names::CREATOR_ID) {
-            let data: S = serde_json::from_value(value)?;
-            document.creator_id = Some(data.try_into()?);
+            if !value.is_null() {
+                let data: S = serde_json::from_value(value)?;
+                document.creator_id = Some(data.try_into().map_err(Into::into)?);
+            }
         }
 
         let platform_value: Value = document_value.into();

packages/rs-dpp/src/group/action_event.rs

@@ -2,10 +2,16 @@ use crate::tokens::token_event::TokenEvent;
 use crate::ProtocolError;
 use bincode::{Decode, Encode};
 use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize};
+#[cfg(feature = "state-transition-serde-conversion")]
+use serde::{Deserialize, Serialize};
 
 #[derive(
     Debug, PartialEq, PartialOrd, Clone, Eq, Encode, Decode, PlatformDeserialize, PlatformSerialize,
 )]
+#[cfg_attr(
+    feature = "state-transition-serde-conversion",
+    derive(Serialize, Deserialize)
+)]
 #[platform_serialize(unversioned)] //versioned directly, no need to use platform_version
 pub enum GroupActionEvent {
     TokenEvent(TokenEvent),

packages/rs-dpp/src/group/group_action/mod.rs

@@ -7,10 +7,16 @@ use crate::ProtocolError;
 use bincode::{Decode, Encode};
 use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize};
 use platform_value::Identifier;
+#[cfg(feature = "state-transition-serde-conversion")]
+use serde::{Deserialize, Serialize};
 
 #[derive(
     Debug, PartialEq, PartialOrd, Clone, Eq, Encode, Decode, PlatformDeserialize, PlatformSerialize,
 )]
+#[cfg_attr(
+    feature = "state-transition-serde-conversion",
+    derive(Serialize, Deserialize)
+)]
 #[platform_serialize(unversioned)] //versioned directly, no need to use platform_version
 pub enum GroupAction {
     V0(GroupActionV0),

packages/rs-dpp/src/group/group_action/v0/mod.rs

@@ -5,10 +5,16 @@ use crate::ProtocolError;
 use bincode::{Decode, Encode};
 use platform_serialization_derive::{PlatformDeserialize, PlatformSerialize};
 use platform_value::Identifier;
+#[cfg(feature = "state-transition-serde-conversion")]
+use serde::{Deserialize, Serialize};
 
 #[derive(
     Debug, PartialEq, PartialOrd, Clone, Eq, Encode, Decode, PlatformDeserialize, PlatformSerialize,
 )]
+#[cfg_attr(
+    feature = "state-transition-serde-conversion",
+    derive(Serialize, Deserialize)
+)]
 #[platform_serialize(unversioned)] //versioned directly, no need to use platform_version
 pub struct GroupActionV0 {
     pub contract_id: Identifier,

packages/rs-dpp/src/identity/identity_public_key/conversion/json/mod.rs

@@ -1,2 +1,44 @@
 mod v0;
-pub use v0::*;
+use crate::identity::identity_public_key::v0::IdentityPublicKeyV0;
+use crate::identity::IdentityPublicKey;
+use crate::version::PlatformVersion;
+use crate::ProtocolError;
+use serde_json::Value as JsonValue;
+pub use v0::IdentityPublicKeyJsonConversionMethodsV0;
+
+impl IdentityPublicKeyJsonConversionMethodsV0 for IdentityPublicKey {
+    fn to_json(&self) -> Result<JsonValue, ProtocolError> {
+        match self {
+            IdentityPublicKey::V0(key) => key.to_json(),
+        }
+    }
+
+    fn to_json_object(&self) -> Result<JsonValue, ProtocolError> {
+        match self {
+            IdentityPublicKey::V0(key) => key.to_json_object(),
+        }
+    }
+
+    fn from_json_object(
+        raw_object: JsonValue,
+        platform_version: &PlatformVersion,
+    ) -> Result<Self, ProtocolError>
+    where
+        Self: Sized,
+    {
+        match platform_version
+            .dpp
+            .identity_versions
+            .identity_key_structure_version
+        {
+            0 => {
+                IdentityPublicKeyV0::from_json_object(raw_object, platform_version).map(Into::into)
+            }
+            version => Err(ProtocolError::UnknownVersionMismatch {
+                method: "IdentityPublicKey::from_json_object".to_string(),
+                known_versions: vec![0],
+                received: version,
+            }),
+        }
+    }
+}

packages/rs-dpp/src/identity/identity_public_key/conversion/mod.rs

@@ -1,6 +1,6 @@
-#[cfg(feature = "cbor")]
+#[cfg(feature = "identity-cbor-conversion")]
 pub mod cbor;
-#[cfg(feature = "json-object")]
+#[cfg(feature = "identity-json-conversion")]
 pub mod json;
-#[cfg(feature = "platform-value")]
+#[cfg(feature = "identity-value-conversion")]
 pub mod platform_value;

packages/rs-dpp/src/identity/identity_public_key/conversion/platform_value/mod.rs

@@ -1,6 +1,48 @@
 mod v0;
+use crate::identity::identity_public_key::v0::IdentityPublicKeyV0;
 use crate::identity::IdentityPublicKey;
 use crate::serialization::ValueConvertible;
+use crate::version::PlatformVersion;
+use crate::ProtocolError;
+use platform_value::Value;
 pub use v0::*;
 
 impl ValueConvertible<'_> for IdentityPublicKey {}
+
+impl IdentityPublicKeyPlatformValueConversionMethodsV0 for IdentityPublicKey {
+    fn to_object(&self) -> Result<Value, ProtocolError> {
+        match self {
+            IdentityPublicKey::V0(key) => key.to_object(),
+        }
+    }
+
+    fn to_cleaned_object(&self) -> Result<Value, ProtocolError> {
+        match self {
+            IdentityPublicKey::V0(key) => key.to_cleaned_object(),
+        }
+    }
+
+    fn into_object(self) -> Result<Value, ProtocolError> {
+        match self {
+            IdentityPublicKey::V0(key) => key.into_object(),
+        }
+    }
+
+    fn from_object(
+        value: Value,
+        platform_version: &PlatformVersion,
+    ) -> Result<Self, ProtocolError> {
+        match platform_version
+            .dpp
+            .identity_versions
+            .identity_key_structure_version
+        {
+            0 => IdentityPublicKeyV0::from_object(value, platform_version).map(Into::into),
+            version => Err(ProtocolError::UnknownVersionMismatch {
+                method: "IdentityPublicKey::from_object".to_string(),
+                known_versions: vec![0],
+                received: version,
+            }),
+        }
+    }
+}