@dashevo/wasm-dpp 0.24.0-dev.12 → 0.24.0-dev.14

package/src/identity/state_transition/identity_update_transition/identity_update_transition.rs

@@ -0,0 +1,448 @@
+use std::convert::TryInto;
+use std::default::Default;
+
+use serde::{Deserialize, Serialize};
+use wasm_bindgen::__rt::Ref;
+use wasm_bindgen::prelude::*;
+
+use crate::identifier::IdentifierWrapper;
+
+use crate::{
+    buffer::Buffer, errors::RustConversionError,
+    identity::state_transition::identity_public_key_transitions::IdentityPublicKeyCreateTransitionWasm,
+    identity::IdentityPublicKeyWasm, state_transition::StateTransitionExecutionContextWasm,
+    with_js_error,
+};
+
+use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
+use crate::errors::from_dpp_err;
+use crate::utils::generic_of_js_val;
+use dpp::identity::state_transition::identity_public_key_transitions::IdentityPublicKeyCreateTransition;
+use dpp::identity::{KeyID, TimestampMillis};
+use dpp::prelude::Revision;
+use dpp::state_transition::StateTransitionIdentitySigned;
+use dpp::{
+    identifier::Identifier,
+    identity::state_transition::identity_update_transition::identity_update_transition::IdentityUpdateTransition,
+    state_transition::StateTransitionLike, util::string_encoding, util::string_encoding::Encoding,
+};
+
+#[wasm_bindgen(js_name=IdentityUpdateTransition)]
+#[derive(Clone)]
+pub struct IdentityUpdateTransitionWasm(IdentityUpdateTransition);
+
+#[derive(Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+struct IdentityUpdateTransitionParams {
+    signature: Option<Vec<u8>>,
+    protocol_version: u32,
+    identity_id: Vec<u8>,
+    revision: Revision,
+    add_public_keys: Option<Vec<IdentityPublicKeyCreateTransition>>,
+    disable_public_keys: Option<Vec<KeyID>>,
+    public_keys_disabled_at: Option<TimestampMillis>,
+}
+
+impl From<IdentityUpdateTransition> for IdentityUpdateTransitionWasm {
+    fn from(v: IdentityUpdateTransition) -> Self {
+        IdentityUpdateTransitionWasm(v)
+    }
+}
+
+impl From<IdentityUpdateTransitionWasm> for IdentityUpdateTransition {
+    fn from(v: IdentityUpdateTransitionWasm) -> Self {
+        v.0
+    }
+}
+
+#[wasm_bindgen(js_class = IdentityUpdateTransition)]
+impl IdentityUpdateTransitionWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(raw_parameters: JsValue) -> Result<IdentityUpdateTransitionWasm, JsValue> {
+        let parameters: IdentityUpdateTransitionParams =
+            with_js_error!(serde_wasm_bindgen::from_value(raw_parameters))?;
+
+        let raw_state_transition = with_js_error!(serde_json::to_value(parameters))?;
+
+        let identity_update_transition = IdentityUpdateTransition::new(raw_state_transition)
+            .map_err(|e| RustConversionError::Error(e.to_string()).to_js_value())?;
+
+        Ok(identity_update_transition.into())
+    }
+
+    #[wasm_bindgen(js_name=setPublicKeysToAdd)]
+    pub fn set_public_keys_to_add(
+        &mut self,
+        public_keys: Option<Vec<JsValue>>,
+    ) -> Result<(), JsValue> {
+        let mut keys_to_add = vec![];
+        if let Some(keys) = public_keys {
+            keys_to_add = keys
+                .iter()
+                .map(|value| {
+                    let public_key: Ref<IdentityPublicKeyCreateTransitionWasm> =
+                        generic_of_js_val::<IdentityPublicKeyCreateTransitionWasm>(
+                            value,
+                            "IdentityPublicKeyCreateTransition",
+                        )?;
+                    Ok(public_key.clone().into())
+                })
+                .collect::<Result<Vec<IdentityPublicKeyCreateTransition>, JsValue>>()?;
+        }
+
+        self.0.set_public_keys_to_add(keys_to_add);
+
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name=getPublicKeysToAdd)]
+    pub fn get_public_keys_add(&self) -> Vec<JsValue> {
+        self.0
+            .get_public_keys_to_add()
+            .iter()
+            .map(|key| IdentityPublicKeyCreateTransitionWasm::from(key.to_owned()).into())
+            .collect()
+    }
+
+    #[wasm_bindgen(getter, js_name=addPublicKeys)]
+    pub fn add_public_keys(&self) -> Vec<JsValue> {
+        self.get_public_keys_add()
+    }
+
+    #[wasm_bindgen(js_name=getPublicKeyIdsToDisable)]
+    pub fn get_public_key_ids_to_disable(&self) -> Vec<JsValue> {
+        self.0
+            .get_public_key_ids_to_disable()
+            .iter()
+            .map(|key| JsValue::from_f64(key.to_owned() as f64))
+            .collect()
+    }
+
+    #[wasm_bindgen(js_name=setPublicKeyIdsToDisable)]
+    pub fn set_public_key_ids_to_disable(&mut self, public_key_ids: Option<Vec<u32>>) {
+        let mut keys = vec![];
+        if let Some(public_key_ids) = public_key_ids {
+            keys = public_key_ids
+                .iter()
+                .map(|key| key.to_owned() as KeyID)
+                .collect::<Vec<KeyID>>();
+        }
+
+        self.0.set_public_key_ids_to_disable(keys);
+    }
+
+    #[wasm_bindgen(js_name=getPublicKeysDisabledAt)]
+    pub fn get_public_keys_disabled_at(&self) -> Option<js_sys::Date> {
+        self.0
+            .get_public_keys_disabled_at()
+            .map(|timestamp| js_sys::Date::new(&JsValue::from_f64(timestamp as f64)))
+    }
+
+    #[wasm_bindgen(js_name=setPublicKeysDisabledAt)]
+    pub fn set_public_keys_disabled_at(&mut self, timestamp: Option<js_sys::Date>) {
+        if let Some(timestamp) = timestamp {
+            self.0
+                .set_public_keys_disabled_at(Some(timestamp.get_time() as TimestampMillis));
+        } else {
+            self.0.set_public_keys_disabled_at(None);
+        }
+    }
+
+    #[wasm_bindgen(js_name=getType)]
+    pub fn get_type(&self) -> u8 {
+        self.0.get_type() as u8
+    }
+
+    #[wasm_bindgen(getter, js_name=identityId)]
+    pub fn identity_id(&self) -> IdentifierWrapper {
+        self.get_identity_id()
+    }
+
+    #[wasm_bindgen(js_name=getIdentityId)]
+    pub fn get_identity_id(&self) -> IdentifierWrapper {
+        (*self.0.get_identity_id()).into()
+    }
+
+    #[wasm_bindgen(js_name=setIdentityId)]
+    pub fn set_identity_id(&mut self, identity_id: &IdentifierWrapper) {
+        self.0.set_identity_id(identity_id.to_owned().into());
+    }
+
+    #[wasm_bindgen(js_name=getOwnerId)]
+    pub fn get_owner_id(&self) -> IdentifierWrapper {
+        (*self.0.get_owner_id()).into()
+    }
+
+    #[wasm_bindgen(js_name=toObject)]
+    pub fn to_object(&self, options: JsValue) -> Result<JsValue, JsValue> {
+        let opts: super::to_object::ToObjectOptions = if options.is_object() {
+            with_js_error!(serde_wasm_bindgen::from_value(options.clone()))?
+        } else {
+            Default::default()
+        };
+
+        let object = super::to_object::to_object_struct(&self.0, opts);
+        let js_object = js_sys::Object::new();
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"type".to_owned().into(),
+            &object.transition_type.into(),
+        )?;
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"protocolVersion".to_owned().into(),
+            &object.protocol_version.into(),
+        )?;
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"revision".to_owned().into(),
+            &object.revision.into(),
+        )?;
+
+        if let Some(signature) = object.signature {
+            let signature_value: JsValue = if signature.is_empty() {
+                JsValue::undefined()
+            } else {
+                Buffer::from_bytes(&signature).into()
+            };
+
+            js_sys::Reflect::set(&js_object, &"signature".to_owned().into(), &signature_value)?;
+
+            if let Some(signature_public_key_id) = object.signature_public_key_id {
+                js_sys::Reflect::set(
+                    &js_object,
+                    &"signaturePublicKeyId".to_owned().into(),
+                    &JsValue::from(signature_public_key_id),
+                )?;
+            } else {
+                js_sys::Reflect::set(
+                    &js_object,
+                    &"signaturePublicKeyId".to_owned().into(),
+                    &JsValue::undefined(),
+                )?;
+            }
+        }
+
+        if let Some(timestamp) = object.public_keys_disabled_at {
+            js_sys::Reflect::set(
+                &js_object,
+                &"publicKeysDisabledAt".to_owned().into(),
+                &(timestamp as u32).into(),
+            )?;
+        }
+
+        if let Some(public_keys_to_add) = object.public_keys_to_add {
+            let keys_objects = public_keys_to_add
+                .into_iter()
+                .map(|key| {
+                    IdentityPublicKeyCreateTransitionWasm::from(key).to_object(options.clone())
+                })
+                .collect::<Result<js_sys::Array, _>>()?;
+
+            js_sys::Reflect::set(
+                &js_object,
+                &"addPublicKeys".to_owned().into(),
+                &keys_objects,
+            )?;
+        }
+
+        if let Some(public_key_ids_to_disable) = object.public_key_ids_to_disable {
+            let public_key_ids_to_disable = public_key_ids_to_disable
+                .into_iter()
+                .map(|key| JsValue::from_f64(key as f64))
+                .collect::<js_sys::Array>();
+
+            js_sys::Reflect::set(
+                &js_object,
+                &"disablePublicKeys".to_owned().into(),
+                &public_key_ids_to_disable.into(),
+            )?;
+        }
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"identityId".to_owned().into(),
+            &Buffer::from_bytes(object.identity_id.buffer.as_slice()),
+        )?;
+
+        Ok(js_object.into())
+    }
+
+    #[wasm_bindgen(js_name=toJSON)]
+    pub fn to_json(&self) -> Result<JsValue, JsValue> {
+        let object = super::to_object::to_object_struct(&self.0, Default::default());
+        let js_object = js_sys::Object::new();
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"type".to_owned().into(),
+            &object.transition_type.into(),
+        )?;
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"protocolVersion".to_owned().into(),
+            &object.protocol_version.into(),
+        )?;
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"revision".to_owned().into(),
+            &object.revision.into(),
+        )?;
+
+        if let Some(signature) = object.signature {
+            let signature_value: JsValue = if signature.is_empty() {
+                JsValue::undefined()
+            } else {
+                string_encoding::encode(signature.as_slice(), Encoding::Base64).into()
+            };
+
+            js_sys::Reflect::set(&js_object, &"signature".to_owned().into(), &signature_value)?;
+
+            if let Some(signature_public_key_id) = object.signature_public_key_id {
+                js_sys::Reflect::set(
+                    &js_object,
+                    &"signaturePublicKeyId".to_owned().into(),
+                    &signature_public_key_id.into(),
+                )?;
+            } else {
+                js_sys::Reflect::set(
+                    &js_object,
+                    &"signaturePublicKeyId".to_owned().into(),
+                    &JsValue::undefined(),
+                )?;
+            }
+        }
+
+        if let Some(timestamp) = object.public_keys_disabled_at {
+            js_sys::Reflect::set(
+                &js_object,
+                &"publicKeysDisabledAt".to_owned().into(),
+                &(timestamp as u32).into(),
+            )?;
+        }
+
+        if let Some(public_keys_to_add) = object.public_keys_to_add {
+            let keys_objects = public_keys_to_add
+                .into_iter()
+                .map(|key| IdentityPublicKeyCreateTransitionWasm::from(key).to_json())
+                .collect::<Result<js_sys::Array, _>>()?;
+
+            js_sys::Reflect::set(
+                &js_object,
+                &"addPublicKeys".to_owned().into(),
+                &keys_objects,
+            )?;
+        }
+
+        if let Some(public_key_ids_to_disable) = object.public_key_ids_to_disable {
+            let public_key_ids_to_disable = public_key_ids_to_disable
+                .into_iter()
+                .map(|key| JsValue::from_f64(key as f64))
+                .collect::<js_sys::Array>();
+
+            js_sys::Reflect::set(
+                &js_object,
+                &"disablePublicKeys".to_owned().into(),
+                &public_key_ids_to_disable.into(),
+            )?;
+        }
+
+        let identity_id = object.identity_id.to_string(Encoding::Base58);
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"identityId".to_owned().into(),
+            &identity_id.into(),
+        )?;
+
+        Ok(js_object.into())
+    }
+
+    #[wasm_bindgen(js_name=getModifiedDataIds)]
+    pub fn get_modified_data_ids(&self) -> Vec<JsValue> {
+        let ids = self.0.get_modified_data_ids();
+
+        ids.into_iter()
+            .map(|id| <IdentifierWrapper as std::convert::From<Identifier>>::from(id).into())
+            .collect()
+    }
+
+    #[wasm_bindgen(js_name=isDataContractStateTransition)]
+    pub fn is_data_contract_state_transition(&self) -> bool {
+        self.0.is_data_contract_state_transition()
+    }
+
+    #[wasm_bindgen(js_name=isDocumentStateTransition)]
+    pub fn is_document_state_transition(&self) -> bool {
+        self.0.is_document_state_transition()
+    }
+
+    #[wasm_bindgen(js_name=isIdentityStateTransition)]
+    pub fn is_identity_state_transition(&self) -> bool {
+        self.0.is_identity_state_transition()
+    }
+
+    #[wasm_bindgen(js_name=setExecutionContext)]
+    pub fn set_execution_context(&mut self, context: &StateTransitionExecutionContextWasm) {
+        self.0.set_execution_context(context.into())
+    }
+
+    #[wasm_bindgen(js_name=getExecutionContext)]
+    pub fn get_execution_context(&mut self) -> StateTransitionExecutionContextWasm {
+        self.0.get_execution_context().into()
+    }
+
+    #[wasm_bindgen(js_name=signByPrivateKey)]
+    pub fn sign_by_private_key(
+        &mut self,
+        private_key: Vec<u8>,
+        key_type: u8,
+        bls: JsBlsAdapter,
+    ) -> Result<(), JsValue> {
+        let bls_adapter = BlsAdapter(bls);
+        let key_type = key_type
+            .try_into()
+            .map_err(|e: anyhow::Error| e.to_string())?;
+
+        self.0
+            .sign_by_private_key(private_key.as_slice(), key_type, &bls_adapter)
+            .map_err(from_dpp_err)
+    }
+
+    #[wasm_bindgen(js_name=getSignature)]
+    pub fn get_signature(&self) -> Buffer {
+        Buffer::from_bytes(self.0.get_signature())
+    }
+
+    #[wasm_bindgen(js_name=getRevision)]
+    pub fn get_revision(&self) -> u32 {
+        self.0.get_revision() as u32
+    }
+
+    #[wasm_bindgen(js_name=setRevision)]
+    pub fn set_revision(&mut self, revision: u32) {
+        self.0.set_revision(revision as u64)
+    }
+
+    #[wasm_bindgen]
+    pub fn sign(
+        &mut self,
+        identity_public_key: &IdentityPublicKeyWasm,
+        private_key: Vec<u8>,
+        bls: JsBlsAdapter,
+    ) -> Result<(), JsValue> {
+        let bls_adapter = BlsAdapter(bls);
+        self.0
+            .sign(
+                &identity_public_key.to_owned().into(),
+                &private_key,
+                &bls_adapter,
+            )
+            .map_err(from_dpp_err)
+    }
+}

package/src/identity/state_transition/identity_update_transition/identity_update_transition_basic_validator.rs

@@ -0,0 +1,94 @@
+use dpp::identity::state_transition::identity_update_transition::{
+    validate_identity_update_transition_basic::ValidateIdentityUpdateTransitionBasic,
+    validate_public_keys::IdentityUpdatePublicKeysValidator,
+};
+use dpp::identity::state_transition::validate_public_key_signatures::PublicKeysSignaturesValidator;
+
+use dpp::version::{ProtocolVersionValidator, COMPATIBILITY_MAP, LATEST_VERSION};
+use dpp::ProtocolError;
+
+use std::sync::Arc;
+use wasm_bindgen::prelude::*;
+
+use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
+use crate::errors::from_dpp_err;
+use crate::utils::ToSerdeJSONExt;
+use crate::validation::ValidationResultWasm;
+
+#[wasm_bindgen(js_name=IdentityUpdateTransitionBasicValidator)]
+pub struct IdentityUpdateTransitionBasicValidatorWasm(
+    ValidateIdentityUpdateTransitionBasic<
+        IdentityUpdatePublicKeysValidator,
+        PublicKeysSignaturesValidator<BlsAdapter>,
+    >,
+);
+
+impl
+    From<
+        ValidateIdentityUpdateTransitionBasic<
+            IdentityUpdatePublicKeysValidator,
+            PublicKeysSignaturesValidator<BlsAdapter>,
+        >,
+    > for IdentityUpdateTransitionBasicValidatorWasm
+{
+    fn from(
+        validator: ValidateIdentityUpdateTransitionBasic<
+            IdentityUpdatePublicKeysValidator,
+            PublicKeysSignaturesValidator<BlsAdapter>,
+        >,
+    ) -> Self {
+        Self(validator)
+    }
+}
+
+#[wasm_bindgen(js_class=IdentityUpdateTransitionBasicValidator)]
+impl IdentityUpdateTransitionBasicValidatorWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        js_bls: JsBlsAdapter,
+    ) -> Result<IdentityUpdateTransitionBasicValidatorWasm, JsValue> {
+        let protocol_version_validator = ProtocolVersionValidator::new(
+            LATEST_VERSION,
+            LATEST_VERSION,
+            COMPATIBILITY_MAP.clone(),
+        );
+
+        let public_keys_validator = IdentityUpdatePublicKeysValidator {};
+
+        let public_keys_signatures_validator =
+            PublicKeysSignaturesValidator::new(BlsAdapter(js_bls));
+
+        let validator = ValidateIdentityUpdateTransitionBasic::new(
+            protocol_version_validator,
+            Arc::new(public_keys_validator),
+            Arc::new(public_keys_signatures_validator),
+        )
+        .map_err(|e| from_dpp_err(ProtocolError::Generic(e.to_string())))?;
+
+        Ok(validator.into())
+    }
+
+    #[wasm_bindgen(js_name=validate)]
+    pub fn validate(
+        &mut self,
+        raw_state_transition: JsValue,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let current_protocol_version =
+            js_sys::Reflect::get(&raw_state_transition, &"protocolVersion".into())
+                .map(|v| v.as_f64().unwrap_or(LATEST_VERSION as f64) as u32)
+                .unwrap_or(LATEST_VERSION);
+
+        self.0
+            .protocol_version_validator()
+            .set_current_protocol_version(current_protocol_version);
+
+        let state_transition_json = raw_state_transition.with_serde_to_json_value()?;
+
+        let validation_result = self
+            .0
+            .validate(&state_transition_json)
+            .map_err(|e| from_dpp_err(e.into()))?;
+
+        Ok(validation_result.map(|_| JsValue::undefined()).into())
+    }
+}

package/src/identity/state_transition/identity_update_transition/identity_update_transition_state_validator.rs

@@ -0,0 +1,53 @@
+use std::sync::Arc;
+use crate::errors::from_dpp_err;
+use crate::state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper};
+use crate::validation::ValidationResultWasm;
+use crate::{IdentityUpdateTransitionWasm};
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsValue;
+use dpp::identity::state_transition::identity_update_transition::identity_update_transition::IdentityUpdateTransition;
+use dpp::identity::state_transition::identity_update_transition::validate_identity_update_transition_state::IdentityUpdateTransitionStateValidator;
+use dpp::identity::state_transition::identity_update_transition::validate_public_keys::IdentityUpdatePublicKeysValidator;
+
+#[wasm_bindgen(js_name=IdentityUpdateTransitionStateValidator)]
+pub struct IdentityUpdateTransitionStateValidatorWasm(
+    IdentityUpdateTransitionStateValidator<
+        IdentityUpdatePublicKeysValidator,
+        ExternalStateRepositoryLikeWrapper,
+    >,
+);
+
+#[wasm_bindgen(js_class=IdentityUpdateTransitionStateValidator)]
+impl IdentityUpdateTransitionStateValidatorWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        state_repository: ExternalStateRepositoryLike,
+    ) -> Result<IdentityUpdateTransitionStateValidatorWasm, JsValue> {
+        let state_repository = ExternalStateRepositoryLikeWrapper::new(state_repository);
+
+        let public_keys_validator = IdentityUpdatePublicKeysValidator {};
+
+        let validator = IdentityUpdateTransitionStateValidator::new(
+            Arc::new(state_repository),
+            Arc::new(public_keys_validator),
+        );
+
+        Ok(Self(validator))
+    }
+
+    #[wasm_bindgen]
+    pub async fn validate(
+        &self,
+        state_transition: &IdentityUpdateTransitionWasm,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let state_transition: IdentityUpdateTransition = state_transition.to_owned().into();
+
+        let validation_result = self
+            .0
+            .validate(&state_transition)
+            .await
+            .map_err(|e| from_dpp_err(e.into()))?;
+
+        Ok(validation_result.map(|_| JsValue::undefined()).into())
+    }
+}

package/src/identity/state_transition/identity_update_transition/mod.rs

@@ -0,0 +1,9 @@
+pub use identity_update_transition::*;
+
+pub mod apply_identity_update_transition;
+pub mod identity_update_public_keys_validator;
+pub mod identity_update_transition;
+pub mod identity_update_transition_basic_validator;
+pub mod identity_update_transition_state_validator;
+
+mod to_object;

package/src/identity/state_transition/identity_update_transition/to_object.rs

@@ -0,0 +1,66 @@
+use dpp::identity::KeyID;
+use dpp::state_transition::StateTransitionIdentitySigned;
+use dpp::{
+    identifier::Identifier,
+    identity::state_transition::identity_public_key_transitions::IdentityPublicKeyCreateTransition,
+    identity::state_transition::identity_update_transition::identity_update_transition::IdentityUpdateTransition,
+    state_transition::StateTransitionLike,
+};
+use serde::Deserialize;
+use std::default::Default;
+
+#[derive(Deserialize, Default)]
+#[serde(rename_all = "camelCase")]
+pub struct ToObjectOptions {
+    pub skip_signature: Option<bool>,
+}
+
+#[derive(Default)]
+pub struct ToObject {
+    pub transition_type: u8,
+    pub protocol_version: u32,
+    pub revision: u32,
+    pub signature: Option<Vec<u8>>,
+    pub signature_public_key_id: Option<KeyID>,
+    pub public_keys_disabled_at: Option<u64>,
+    pub public_keys_to_add: Option<Vec<IdentityPublicKeyCreateTransition>>,
+    pub public_key_ids_to_disable: Option<Vec<KeyID>>,
+    pub identity_id: Identifier,
+}
+
+pub fn to_object_struct(
+    transition: &IdentityUpdateTransition,
+    options: ToObjectOptions,
+) -> ToObject {
+    let mut to_object = ToObject {
+        transition_type: transition.get_type() as u8,
+        protocol_version: transition.get_protocol_version(),
+        revision: transition.get_revision() as u32,
+        identity_id: transition.get_identity_id().to_owned(),
+        ..ToObject::default()
+    };
+
+    if !options.skip_signature.unwrap_or(false) {
+        let signature = Some(transition.get_signature().to_owned());
+        if let Some(signature) = &signature {
+            if !signature.is_empty() {
+                to_object.signature_public_key_id = transition.get_signature_public_key_id()
+            }
+        }
+        to_object.signature = signature;
+    }
+
+    to_object.public_keys_disabled_at = transition.get_public_keys_disabled_at();
+
+    let public_keys_to_add = transition.get_public_keys_to_add();
+    if !public_keys_to_add.is_empty() {
+        to_object.public_keys_to_add = Some(public_keys_to_add.to_owned());
+    }
+
+    let public_key_ids_to_disable = transition.get_public_key_ids_to_disable();
+    if !public_key_ids_to_disable.is_empty() {
+        to_object.public_key_ids_to_disable = Some(public_key_ids_to_disable.to_owned());
+    }
+
+    to_object
+}

package/src/identity/state_transition/mod.rs

@@ -0,0 +1,12 @@
+pub use asset_lock_proof::*;
+pub use identity_create_transition::*;
+pub use identity_topup_transition::*;
+pub use identity_update_transition::*;
+pub use validate_public_key_signatures::*;
+
+mod asset_lock_proof;
+mod identity_create_transition;
+pub(crate) mod identity_public_key_transitions;
+mod identity_topup_transition;
+mod identity_update_transition;
+mod validate_public_key_signatures;