@dashevo/wasm-dpp 0.24.0-dev.11 → 0.24.0-dev.13

package/src/errors/consensus/basic/identity/duplicated_identity_public_key_id_error.rs

@@ -16,12 +16,12 @@ impl From<&DuplicatedIdentityPublicKeyIdError> for DuplicatedIdentityPublicKeyId
 #[wasm_bindgen(js_class=DuplicatedIdentityPublicKeyIdError)]
 impl DuplicatedIdentityPublicKeyIdErrorWasm {
     #[wasm_bindgen(js_name=getDuplicatedIds)]
-    pub fn duplicated_ids(&self) -> Vec<u32> {
+    pub fn duplicated_ids(&self) -> js_sys::Array {
         // TODO: key ids probably should be u32
         self.inner
             .duplicated_ids()
             .iter()
-            .map(|id| *id as u32)
+            .map(|id| JsValue::from(*id as u32))
             .collect()
     }
 

package/src/errors/consensus/basic/identity/identity_asset_lock_proof_locked_transaction_mismatch_error.rs

@@ -1,5 +1,6 @@
 use dpp::consensus::basic::identity::IdentityAssetLockProofLockedTransactionMismatchError;
 use dpp::consensus::ConsensusError;
+use dpp::dashcore::hashes::Hash;
 use wasm_bindgen::prelude::*;
 
 use crate::buffer::Buffer;
@@ -22,13 +23,16 @@ impl IdentityAssetLockProofLockedTransactionMismatchErrorWasm {
     #[wasm_bindgen(js_name=getInstantLockTransactionId)]
     pub fn instant_lock_transaction_id(&self) -> Buffer {
         let tx_id = self.inner.instant_lock_transaction_id();
-        Buffer::from_bytes(tx_id.to_vec().as_ref())
+        Buffer::from_bytes(&tx_id)
     }
 
     #[wasm_bindgen(js_name=getAssetLockTransactionId)]
     pub fn asset_lock_transaction_id(&self) -> Buffer {
         let tx_id = self.inner.asset_lock_transaction_id();
-        Buffer::from_bytes(tx_id.to_vec().as_ref())
+        let mut hash_bytes = tx_id.as_hash().into_inner();
+        hash_bytes.reverse();
+
+        Buffer::from_bytes(&hash_bytes)
     }
 
     #[wasm_bindgen(js_name=getCode)]

package/src/errors/consensus/basic/identity/identity_asset_lock_transaction_out_point_already_exists_error.rs

@@ -1,5 +1,6 @@
 use dpp::consensus::basic::identity::IdentityAssetLockTransactionOutPointAlreadyExistsError;
 use dpp::consensus::ConsensusError;
+use dpp::dashcore::hashes::Hash;
 use wasm_bindgen::prelude::*;
 
 use crate::buffer::Buffer;
@@ -19,7 +20,7 @@ impl From<&IdentityAssetLockTransactionOutPointAlreadyExistsError>
 
 #[wasm_bindgen(js_class=IdentityAssetLockTransactionOutPointAlreadyExistsError)]
 impl IdentityAssetLockTransactionOutPointAlreadyExistsErrorWasm {
-    #[wasm_bindgen(js_name=getDuplicatedIds)]
+    #[wasm_bindgen(js_name=getOutputIndex)]
     pub fn output_index(&self) -> usize {
         self.inner.output_index()
     }
@@ -27,7 +28,9 @@ impl IdentityAssetLockTransactionOutPointAlreadyExistsErrorWasm {
     #[wasm_bindgen(js_name=getTransactionId)]
     pub fn transaction_id(&self) -> Buffer {
         let tx_id = self.inner.transaction_id();
-        Buffer::from_bytes(tx_id.to_vec().as_ref())
+        let mut tx_id_bytes = tx_id.as_hash().into_inner();
+        tx_id_bytes.reverse();
+        Buffer::from_bytes(&tx_id_bytes)
     }
 
     #[wasm_bindgen(js_name=getCode)]

package/src/errors/consensus/basic/identity/invalid_asset_lock_proof_transaction_height_error.rs

@@ -22,9 +22,9 @@ impl InvalidAssetLockProofTransactionHeightErrorWasm {
         self.inner.proof_core_chain_locked_height()
     }
 
-    #[wasm_bindgen(js_name=getCurrentCoreChainLockedHeight)]
-    pub fn current_core_chain_locked_height(&self) -> Option<u32> {
-        self.inner.current_core_chain_locked_height()
+    #[wasm_bindgen(js_name=getTransactionHeight)]
+    pub fn transaction_height(&self) -> Option<u32> {
+        self.inner.transaction_height()
     }
 
     #[wasm_bindgen(js_name=getCode)]

package/src/errors/consensus/basic/identity/invalid_identity_public_key_security_level_error.rs

@@ -25,12 +25,12 @@ impl InvalidIdentityPublicKeySecurityLevelErrorWasm {
         self.inner.public_key_id() as u32
     }
 
-    #[wasm_bindgen(js_name=getPurpose)]
+    #[wasm_bindgen(js_name=getPublicKeyPurpose)]
     pub fn purpose(&self) -> u8 {
         self.inner.purpose() as u8
     }
 
-    #[wasm_bindgen(js_name=getSecurityLevel)]
+    #[wasm_bindgen(js_name=getPublicKeySecurityLevel)]
     pub fn security_level(&self) -> u8 {
         self.inner.security_level() as u8
     }

package/src/errors/consensus/basic/json_schema_error.rs

@@ -141,7 +141,7 @@ impl From<&ValidationErrorKind> for Params {
                 .build(),
             ValidationErrorKind::MinItems { limit } => ParamsBuilder::new()
                 .set_keyword("minItems")
-                .add_param("maximum", Value::from(*limit))
+                .add_param("minItems", Value::from(*limit))
                 .build(),
             ValidationErrorKind::Minimum { limit } => ParamsBuilder::new()
                 .set_keyword("minimum")

package/src/errors/consensus_error.rs

@@ -36,8 +36,9 @@ use crate::errors::consensus::basic::data_contract::{
     IncompatibleDataContractSchemaErrorWasm, InvalidDataContractIdErrorWasm,
 };
 use crate::errors::consensus::basic::document::{
-    DuplicateDocumentTransitionsWithIdsError, InvalidDocumentTransitionActionErrorWasm,
-    InvalidDocumentTransitionIdErrorWasm, MissingDataContractIdErrorWasm,
+    DuplicateDocumentTransitionsWithIdsErrorWasm, DuplicateDocumentTransitionsWithIndicesErrorWasm,
+    InvalidDocumentTransitionActionErrorWasm, InvalidDocumentTransitionIdErrorWasm,
+    MissingDataContractIdErrorWasm, MissingDocumentTypeErrorWasm,
 };
 use crate::errors::consensus::basic::state_transition::{
     InvalidStateTransitionTypeErrorWasm, MissingStateTransitionTypeErrorWasm,
@@ -62,7 +63,7 @@ use crate::errors::consensus::state::identity::{
 use dpp::errors::DataTriggerError;
 
 use super::consensus::basic::data_contract::{
-    DataContractMaxDepthErrorWasm, DuplicateIndexErrorWasm, DuplicateIndexNameErrorWasm,
+    DataContractMaxDepthExceedErrorWasm, DuplicateIndexErrorWasm, DuplicateIndexNameErrorWasm,
     IncompatibleRe2PatternErrorWasm, InvalidCompoundIndexErrorWasm,
     InvalidDataContractVersionErrorWasm, InvalidIndexPropertyTypeErrorWasm,
     InvalidIndexedPropertyConstraintErrorWasm, InvalidJsonSchemaRefErrorWasm,
@@ -75,7 +76,7 @@ use super::consensus::basic::decode::{
 use super::consensus::basic::document::{
     DataContractNotPresentErrorWasm, InconsistentCompoundIndexDataErrorWasm,
     InvalidDocumentTypeErrorWasm, MissingDocumentTransitionActionErrorWasm,
-    MissingDocumentTypeErrorWasm,
+    MissingDocumentTransitionTypeErrorWasm,
 };
 use super::consensus::basic::identity::{
     InvalidIdentityPublicKeyTypeErrorWasm, MissingPublicKeyErrorWasm,
@@ -99,7 +100,7 @@ pub fn from_consensus_error_ref(e: &DPPConsensusError) -> JsValue {
         DPPConsensusError::IncompatibleProtocolVersionError(e) => {
             IncompatibleProtocolVersionErrorWasm::from(e).into()
         }
-        DPPConsensusError::DuplicatedIdentityPublicKeyIdError(e) => {
+        DPPConsensusError::DuplicatedIdentityPublicKeyBasicIdError(e) => {
             DuplicatedIdentityPublicKeyIdErrorWasm::from(e).into()
         }
         DPPConsensusError::InvalidIdentityPublicKeyDataError(e) => {
@@ -108,7 +109,7 @@ pub fn from_consensus_error_ref(e: &DPPConsensusError) -> JsValue {
         DPPConsensusError::InvalidIdentityPublicKeySecurityLevelError(e) => {
             InvalidIdentityPublicKeySecurityLevelErrorWasm::from(e).into()
         }
-        DPPConsensusError::DuplicatedIdentityPublicKeyError(e) => {
+        DPPConsensusError::DuplicatedIdentityPublicKeyBasicError(e) => {
             DuplicatedIdentityPublicKeyErrorWasm::from(e).into()
         }
         DPPConsensusError::MissingMasterPublicKeyError(e) => {
@@ -351,7 +352,7 @@ fn from_basic_error(basic_error: &Box<BasicError>) -> JsValue {
             version,
         } => InvalidDataContractVersionErrorWasm::new(*expected_version, *version, code).into(),
         BasicError::DataContractMaxDepthExceedError(depth) => {
-            DataContractMaxDepthErrorWasm::new(*depth, code).into()
+            DataContractMaxDepthExceedErrorWasm::new(*depth, code).into()
         }
         BasicError::InvalidDocumentTypeError {
             document_type,
@@ -457,6 +458,9 @@ fn from_basic_error(basic_error: &Box<BasicError>) -> JsValue {
             code,
         )
         .into(),
+        BasicError::MissingDocumentTransitionTypeError => {
+            MissingDocumentTransitionTypeErrorWasm::new(code).into()
+        }
         BasicError::MissingDocumentTypeError => MissingDocumentTypeErrorWasm::new(code).into(),
         BasicError::MissingDocumentTransitionActionError => {
             MissingDocumentTransitionActionErrorWasm::new(code).into()
@@ -472,8 +476,11 @@ fn from_basic_error(basic_error: &Box<BasicError>) -> JsValue {
             InvalidDocumentTransitionIdErrorWasm::new(expected_id.clone(), invalid_id.clone(), code)
                 .into()
         }
+        BasicError::DuplicateDocumentTransitionsWithIndicesError { references } => {
+            DuplicateDocumentTransitionsWithIndicesErrorWasm::new(references.clone(), code).into()
+        }
         BasicError::DuplicateDocumentTransitionsWithIdsError { references } => {
-            DuplicateDocumentTransitionsWithIdsError::new(references.clone(), code).into()
+            DuplicateDocumentTransitionsWithIdsErrorWasm::new(references.clone(), code).into()
         }
         BasicError::MissingDataContractIdError => MissingDataContractIdErrorWasm::new(code).into(),
         BasicError::InvalidIdentifierError {

package/src/errors/dpp_error.rs

@@ -0,0 +1,17 @@
+use crate::identity::errors::{
+    AssetLockOutputNotFoundErrorWasm, AssetLockTransactionIsNotFoundErrorWasm,
+};
+use dpp::DPPError;
+use wasm_bindgen::JsValue;
+
+pub fn from_dpp_error_ref(e: &DPPError) -> JsValue {
+    match e {
+        DPPError::AssetLockOutputNotFoundError(e) => {
+            AssetLockOutputNotFoundErrorWasm::from(e).into()
+        }
+        DPPError::AssetLockTransactionIsNotFoundError(e) => {
+            AssetLockTransactionIsNotFoundErrorWasm::from(e).into()
+        }
+        _ => unimplemented!(),
+    }
+}

package/src/errors/from.rs

@@ -5,8 +5,13 @@ use dpp::errors::ProtocolError;
 use crate::data_contract::errors::from_data_contract_to_js_error;
 use crate::document::errors::from_document_to_js_error;
 
+use super::consensus_error::from_consensus_error;
+
 pub fn from_dpp_err(pe: ProtocolError) -> JsValue {
     match pe {
+        ProtocolError::AbstractConsensusError(consensus_error) => {
+            from_consensus_error(*consensus_error)
+        }
         ProtocolError::DataContractError(e) => from_data_contract_to_js_error(e),
 
         ProtocolError::Document(e) => from_document_to_js_error(*e),
@@ -19,6 +24,6 @@ pub fn from_dpp_err(pe: ProtocolError) -> JsValue {
         )
         .into(),
 
-        _ => JsValue::from_str(&format!("Kek: {:#}", pe,)),
+        _ => JsValue::from_str(&format!("Error conversion not implemented: {pe:#}",)),
     }
 }

package/src/errors/js_conversion.rs

@@ -41,23 +41,38 @@ impl From<serde_wasm_bindgen::Error> for RustConversionError {
 #[macro_export]
 macro_rules! with_js_error {
     ($o:expr) => {
-        $o.map_err(|e| RustConversionError::from(e).to_js_value())
+        $o.map_err(|e| $crate::errors::RustConversionError::from(e).to_js_value())
     };
 }
 
 #[macro_export]
 macro_rules! bail_js {
     ($msg:literal) => ({
-        return Err(RustConversionError::from(String::from($msg)).to_js_value())
+        return Err($crate::errors::RustConversionError::from(String::from($msg)).to_js_value())
     });
 
     ($err:expr $(,)?) => ({
         use $crate::private::kind::*;
-        return Err(RustConversionError::from($err).to_js_value())
+        return Err($crate::errors::RustConversionError::from($err).to_js_value())
     });
 
     ($fmt:expr, $($arg:tt)*) => {
-        return Err(RustConversionError::from(format!($fmt, $($arg)*)).to_js_value())
+        return Err($crate::errors::RustConversionError::from(format!($fmt, $($arg)*)).to_js_value())
     };
 
 }
+
+#[macro_export]
+macro_rules! console_log {
+    ($msg:literal) => {{
+        web_sys::console::log_1(&format!($msg).into())
+    }};
+
+    ($msg:expr $(,)?) => {{
+        web_sys::console::log_1(&format!("{}", $msg).into())
+    }};
+
+    ($fmt:expr, $($arg:tt)*) => {
+        web_sys::console::log_1(&format!($fmt, $($arg)*).into())
+    };
+}

package/src/errors/mod.rs

@@ -5,6 +5,9 @@ pub mod consensus;
 pub mod consensus_error;
 mod from;
 mod js_conversion;
+pub mod protocol_error;
 mod public_key_validation_error;
 
 pub use public_key_validation_error::*;
+
+pub mod dpp_error;

package/src/errors/protocol_error.rs

@@ -0,0 +1,15 @@
+use wasm_bindgen::{JsError, JsValue};
+
+use super::consensus_error::from_consensus_error;
+
+pub fn from_protocol_error(protocol_error: dpp::ProtocolError) -> JsValue {
+    match protocol_error {
+        dpp::ProtocolError::AbstractConsensusError(consensus_error) => {
+            from_consensus_error(*consensus_error)
+        }
+        dpp::ProtocolError::Error(anyhow_error) => {
+            format!("Non-protocol error: {}", anyhow_error).into()
+        }
+        _ => todo!("Implement protocol error conversions"),
+    }
+}

package/src/{identifier.rs → identifier/mod.rs}

@@ -1,9 +1,16 @@
+use dpp::prelude::Identifier;
+use dpp::util::string_encoding::Encoding;
+use itertools::Itertools;
 pub use serde::{Deserialize, Serialize};
+use serde_json::Value;
 use wasm_bindgen::prelude::*;
 use wasm_bindgen::JsCast;
 
+use crate::bail_js;
 use crate::buffer::Buffer;
 use crate::errors::from_dpp_err;
+use crate::utils::ToSerdeJSONExt;
+use crate::utils::WithJsError;
 use dpp::identifier;
 
 #[derive(Serialize, Deserialize, PartialEq, Eq)]
@@ -35,7 +42,6 @@ impl std::convert::From<identifier::Identifier> for IdentifierWrapper {
 impl IdentifierWrapper {
     #[wasm_bindgen(constructor)]
     pub fn new(buffer: Vec<u8>) -> Result<IdentifierWrapper, JsValue> {
-        // TODO: remove unwrap
         let identifier = identifier::Identifier::from_bytes(&buffer).map_err(from_dpp_err)?;
 
         Ok(IdentifierWrapper {
@@ -73,7 +79,7 @@ impl IdentifierWrapper {
 
     #[wasm_bindgen(js_name=toBuffer)]
     pub fn to_buffer(&self) -> Buffer {
-        Buffer::from_bytes(self.wrapped.buffer.as_slice())
+        Buffer::from_bytes(&self.wrapped.buffer)
     }
 
     #[wasm_bindgen(js_name=toJSON)]
@@ -97,7 +103,46 @@ impl IdentifierWrapper {
         self.wrapped.buffer.len()
     }
 
-    pub fn inner(&self) -> Vec<u8> {
+    #[wasm_bindgen(js_name=toBytes)]
+    pub fn to_bytes(&self) -> Vec<u8> {
         self.wrapped.buffer.to_vec()
     }
+
+    #[wasm_bindgen(js_name=clone)]
+    pub fn deep_clone(&self) -> IdentifierWrapper {
+        IdentifierWrapper {
+            wrapped: self.wrapped.clone(),
+        }
+    }
+}
+
+impl IdentifierWrapper {
+    pub fn inner(self) -> Identifier {
+        self.wrapped
+    }
+}
+
+/// tries to create identifier from
+pub fn identifier_from_js_value(js_value: &JsValue) -> Result<Identifier, JsValue> {
+    let value = js_value.with_serde_to_json_value()?;
+    match value {
+        Value::Array(arr) => {
+            let bytes: Vec<u8> = arr.into_iter().map(value_to_u8).try_collect()?;
+            Identifier::from_bytes(&bytes).with_js_error()
+        }
+        Value::String(string) => Identifier::from_string(&string, Encoding::Base58).with_js_error(),
+        _ => {
+            bail_js!("Invalid ID. Expected array or string")
+        }
+    }
+}
+
+fn value_to_u8(v: Value) -> Result<u8, JsValue> {
+    let number = v
+        .as_u64()
+        .ok_or_else(|| format!("failed converting {} into u64", v))?;
+    if number > u8::MAX as u64 {
+        bail_js!("the integer in the array isn't a byte: {}", number);
+    }
+    Ok(number as u8)
 }

package/src/identity/errors/asset_lock_output_not_found_error.rs

@@ -0,0 +1,11 @@
+use dpp::identity::errors::AssetLockOutputNotFoundError;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=AssetLockOutputNotFoundError)]
+pub struct AssetLockOutputNotFoundErrorWasm(AssetLockOutputNotFoundError);
+
+impl From<&AssetLockOutputNotFoundError> for AssetLockOutputNotFoundErrorWasm {
+    fn from(e: &AssetLockOutputNotFoundError) -> Self {
+        Self(e.clone())
+    }
+}

package/src/identity/errors/asset_lock_transaction_is_not_found_error.rs

@@ -0,0 +1,20 @@
+use dpp::dashcore::hashes::hex::ToHex;
+use dpp::identity::errors::AssetLockTransactionIsNotFoundError;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=AssetLockTransactionIsNotFoundError)]
+pub struct AssetLockTransactionIsNotFoundErrorWasm(AssetLockTransactionIsNotFoundError);
+
+impl From<&AssetLockTransactionIsNotFoundError> for AssetLockTransactionIsNotFoundErrorWasm {
+    fn from(e: &AssetLockTransactionIsNotFoundError) -> Self {
+        Self(e.clone())
+    }
+}
+
+#[wasm_bindgen(js_class=AssetLockTransactionIsNotFoundError)]
+impl AssetLockTransactionIsNotFoundErrorWasm {
+    #[wasm_bindgen(js_name=getTransactionId)]
+    pub fn transaction_id(&self) -> JsValue {
+        self.0.transaction_id().to_hex().into()
+    }
+}

package/src/identity/errors/mod.rs

@@ -0,0 +1,7 @@
+pub use asset_lock_output_not_found_error::*;
+pub use asset_lock_transaction_is_not_found_error::*;
+pub use unknown_asset_lock_proof_type_error::*;
+
+mod asset_lock_output_not_found_error;
+mod asset_lock_transaction_is_not_found_error;
+mod unknown_asset_lock_proof_type_error;

package/src/identity/errors/unknown_asset_lock_proof_type_error.rs

@@ -0,0 +1,26 @@
+use dpp::identity::errors::UnknownAssetLockProofTypeError;
+use wasm_bindgen::prelude::*;
+
+#[derive(Clone)]
+#[wasm_bindgen(js_name=UnknownAssetLockProofTypeError)]
+pub struct UnknownAssetLockProofTypeErrorWasm(UnknownAssetLockProofTypeError);
+
+impl From<&UnknownAssetLockProofTypeError> for UnknownAssetLockProofTypeErrorWasm {
+    fn from(e: &UnknownAssetLockProofTypeError) -> Self {
+        Self(e.clone())
+    }
+}
+
+impl From<UnknownAssetLockProofTypeError> for UnknownAssetLockProofTypeErrorWasm {
+    fn from(e: UnknownAssetLockProofTypeError) -> Self {
+        Self(e)
+    }
+}
+
+#[wasm_bindgen(js_class=UnknownAssetLockProofTypeError)]
+impl UnknownAssetLockProofTypeErrorWasm {
+    #[wasm_bindgen(js_name=getType)]
+    pub fn get_type(&self) -> Option<u8> {
+        self.0.asset_lock_type()
+    }
+}

package/src/{identity_facade.rs → identity/identity_facade.rs}

@@ -6,7 +6,7 @@ use dpp::identity::validation::PublicKeysValidator;
 use dpp::identity::IdentityFacade;
 
 use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
-use crate::validation_result::ValidationResultWasm;
+use crate::validation::ValidationResultWasm;
 use dpp::version::ProtocolVersionValidator;
 use dpp::NonConsensusError;
 
@@ -38,10 +38,8 @@ impl IdentityFacadeWasm {
         let identity_json = serde_wasm_bindgen::from_value(raw_identity_object)
             .expect("unable to serialize identity");
         // TODO: handle the case when
-        self.0
-            .validate(&identity_json)
-            .map(|res| res.into())
-            .map_err(|err| err.into())
+        let validation_result = self.0.validate(&identity_json)?;
+        Ok(validation_result.map(|_| JsValue::undefined()).into())
     }
 }
 

package/src/{identity_public_key → identity/identity_public_key}/mod.rs

@@ -14,9 +14,6 @@ mod security_level;
 pub use security_level::*;
 
 mod key_type;
-mod public_keys_validator;
-
-pub use public_keys_validator::*;
 
 pub use key_type::*;
 
@@ -139,32 +136,66 @@ impl IdentityPublicKeyWasm {
     }
 
     #[wasm_bindgen(js_name=toObject)]
-    pub fn to_object(&self, some_option: Option<bool>) -> Result<JsValue, JsValue> {
+    pub fn to_object(&self, skip_signatures: Option<bool>) -> Result<JsValue, JsValue> {
         let val = self
             .0
-            .to_raw_json_object(some_option.unwrap_or(false))
+            .to_raw_json_object(skip_signatures.unwrap_or(false))
             .map_err(|e| from_dpp_err(e.into()))?;
 
         let data_buffer = Buffer::from_bytes(self.0.get_data());
-        let signature_buffer = Buffer::from_bytes(self.0.get_signature());
 
         let json = val.to_string();
         let js_object = js_sys::JSON::parse(&json)?;
 
         js_sys::Reflect::set(
             &js_object,
-            &"data".to_owned().into(),
-            &JsValue::from(data_buffer),
+            &JsValue::from_str("type"),
+            &JsValue::from(self.get_type()),
         )?;
 
         js_sys::Reflect::set(
             &js_object,
-            &"signature".to_owned().into(),
-            &JsValue::from(signature_buffer),
+            &"data".to_owned().into(),
+            &JsValue::from(data_buffer),
         )?;
 
+        if !skip_signatures.unwrap_or(false) {
+            let signature = self.0.get_signature();
+            if !signature.is_empty() {
+                js_sys::Reflect::set(
+                    &js_object,
+                    &"signature".to_owned().into(),
+                    &JsValue::from(Buffer::from_bytes(signature)),
+                )?;
+            }
+        }
+
         Ok(js_object)
     }
+
+    #[wasm_bindgen(js_name=setSignature)]
+    pub fn set_signature(&mut self, signature: Vec<u8>) {
+        self.0.set_signature(signature);
+    }
+
+    #[wasm_bindgen(js_name=getSignature)]
+    pub fn get_signature(&mut self) -> Buffer {
+        Buffer::from_bytes(self.0.get_signature())
+    }
+}
+
+impl IdentityPublicKeyWasm {
+    pub fn into_inner(self) -> IdentityPublicKey {
+        self.0
+    }
+
+    pub fn inner(&self) -> &IdentityPublicKey {
+        &self.0
+    }
+
+    pub fn inner_mut(&mut self) -> &mut IdentityPublicKey {
+        &mut self.0
+    }
 }
 
 impl From<IdentityPublicKey> for IdentityPublicKeyWasm {

package/src/{identity.rs → identity/mod.rs}

@@ -1,3 +1,7 @@
+pub mod identity_facade;
+mod identity_public_key;
+mod validation;
+
 use js_sys::Array;
 use serde_json::Value;
 use wasm_bindgen::prelude::*;
@@ -12,18 +16,27 @@ use crate::errors::from_dpp_err;
 use crate::identifier::IdentifierWrapper;
 use crate::utils;
 use crate::utils::to_vec_of_serde_values;
-use crate::IdentityPublicKeyWasm;
 use crate::MetadataWasm;
+pub use identity_public_key::*;
+
+pub use state_transition::*;
+
+pub mod errors;
+pub mod state_transition;
 
 #[wasm_bindgen(js_name=Identity)]
 #[derive(Clone)]
 pub struct IdentityWasm(Identity);
 
-#[wasm_bindgen(js_name=AssetLockProof)]
-pub struct AssetLockProofWasm(AssetLockProof);
-impl From<AssetLockProof> for AssetLockProofWasm {
-    fn from(v: AssetLockProof) -> Self {
-        AssetLockProofWasm(v)
+impl From<IdentityWasm> for Identity {
+    fn from(identity: IdentityWasm) -> Self {
+        identity.0
+    }
+}
+
+impl From<Identity> for IdentityWasm {
+    fn from(identity: Identity) -> Self {
+        Self(identity)
     }
 }
 
@@ -60,12 +73,7 @@ impl IdentityWasm {
             .into_iter()
             .map(IdentityPublicKey::from_json_object)
             .collect::<Result<_, _>>()
-            .map_err(|e| {
-                format!(
-                    "converting to collection of IdentityPublicKeys failed: {:#}",
-                    e
-                )
-            })?;
+            .map_err(|e| format!("converting to collection of IdentityPublicKeys failed: {e:#}"))?;
 
         self.0.set_public_keys(public_keys);