@dashevo/wasm-dpp 0.25.0-dev.9 → 0.25.1

package/src/errors/consensus/state/document/document_not_found_error.rs

@@ -2,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::document::document_not_found_error::DocumentNotFoundError;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DocumentNotFoundError)]
@@ -31,13 +32,4 @@ impl DocumentNotFoundErrorWasm {
     pub fn message(&self) -> String {
         self.inner.to_string()
     }
-
-    #[wasm_bindgen(js_name=serialize)]
-    pub fn serialize(&self) -> Result<Buffer, JsError> {
-        let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
-            .map_err(JsError::from)?;
-
-        Ok(Buffer::from_bytes(bytes.as_slice()))
-    }
 }

package/src/errors/consensus/state/document/document_owner_id_mismatch_error.rs

@@ -2,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::document::document_owner_id_mismatch_error::DocumentOwnerIdMismatchError;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DocumentOwnerIdMismatchError)]
@@ -41,13 +42,4 @@ impl DocumentOwnerIdMismatchErrorWasm {
     pub fn message(&self) -> String {
         self.inner.to_string()
     }
-
-    #[wasm_bindgen(js_name=serialize)]
-    pub fn serialize(&self) -> Result<Buffer, JsError> {
-        let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
-            .map_err(JsError::from)?;
-
-        Ok(Buffer::from_bytes(bytes.as_slice()))
-    }
 }

package/src/errors/consensus/state/document/document_timestamp_window_violation_error.rs

@@ -2,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::document::document_timestamp_window_violation_error::DocumentTimestampWindowViolationError;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DocumentTimestampWindowViolationError)]
@@ -57,13 +58,4 @@ impl DocumentTimestampWindowViolationErrorWasm {
     pub fn message(&self) -> String {
         self.inner.to_string()
     }
-
-    #[wasm_bindgen(js_name=serialize)]
-    pub fn serialize(&self) -> Result<Buffer, JsError> {
-        let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
-            .map_err(JsError::from)?;
-
-        Ok(Buffer::from_bytes(bytes.as_slice()))
-    }
 }

package/src/errors/consensus/state/document/document_timestamps_are_equal_error.rs

@@ -0,0 +1,34 @@
+use crate::buffer::Buffer;
+use dpp::consensus::codes::ErrorWithCode;
+use dpp::consensus::state::document::document_timestamps_are_equal_error::DocumentTimestampsAreEqualError;
+use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=DocumentTimestampsAreEqualError)]
+pub struct DocumentTimestampsAreEqualErrorWasm {
+    inner: DocumentTimestampsAreEqualError,
+}
+
+impl From<&DocumentTimestampsAreEqualError> for DocumentTimestampsAreEqualErrorWasm {
+    fn from(e: &DocumentTimestampsAreEqualError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+#[wasm_bindgen(js_class=DocumentTimestampsAreEqualError)]
+impl DocumentTimestampsAreEqualErrorWasm {
+    #[wasm_bindgen(js_name=getDocumentId)]
+    pub fn document_id(&self) -> Buffer {
+        Buffer::from_bytes(self.inner.document_id().as_bytes())
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        ConsensusError::from(self.inner.clone()).code()
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn message(&self) -> String {
+        self.inner.to_string()
+    }
+}

package/src/errors/consensus/state/document/document_timestamps_mismatch_error.rs

@@ -2,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::document::document_timestamps_mismatch_error::DocumentTimestampsMismatchError;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DocumentTimestampsMismatchError)]
@@ -30,13 +31,4 @@ impl DocumentTimestampsMismatchErrorWasm {
     pub fn message(&self) -> String {
         self.inner.to_string()
     }
-
-    #[wasm_bindgen(js_name=serialize)]
-    pub fn serialize(&self) -> Result<Buffer, JsError> {
-        let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
-            .map_err(JsError::from)?;
-
-        Ok(Buffer::from_bytes(bytes.as_slice()))
-    }
 }

package/src/errors/consensus/state/document/duplicate_unique_index_error.rs

@@ -2,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::document::duplicate_unique_index_error::DuplicateUniqueIndexError;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use js_sys::JsString;
 use wasm_bindgen::prelude::*;
 
@@ -41,13 +42,4 @@ impl DuplicateUniqueIndexErrorWasm {
     pub fn message(&self) -> String {
         self.inner.to_string()
     }
-
-    #[wasm_bindgen(js_name=serialize)]
-    pub fn serialize(&self) -> Result<Buffer, JsError> {
-        let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
-            .map_err(JsError::from)?;
-
-        Ok(Buffer::from_bytes(bytes.as_slice()))
-    }
 }

package/src/errors/consensus/state/document/invalid_document_revision_error.rs

@@ -3,6 +3,7 @@ use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::document::invalid_document_revision_error::InvalidDocumentRevisionError;
 use dpp::consensus::ConsensusError;
 use dpp::prelude::Revision;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=InvalidDocumentRevisionError)]
@@ -23,9 +24,14 @@ impl InvalidDocumentRevisionErrorWasm {
         Buffer::from_bytes(self.inner.document_id().as_bytes())
     }
 
-    #[wasm_bindgen(js_name=getCurrentRevision)]
-    pub fn current_revision(&self) -> Option<Revision> {
-        *self.inner.current_revision()
+    #[wasm_bindgen(js_name=getPreviousRevision)]
+    pub fn previous_revision(&self) -> Option<Revision> {
+        *self.inner.previous_revision()
+    }
+
+    #[wasm_bindgen(js_name=getDesiredRevision)]
+    pub fn desired_revision(&self) -> Revision {
+        *self.inner.desired_revision()
     }
 
     #[wasm_bindgen(js_name=getCode)]
@@ -37,13 +43,4 @@ impl InvalidDocumentRevisionErrorWasm {
     pub fn message(&self) -> String {
         self.inner.to_string()
     }
-
-    #[wasm_bindgen(js_name=serialize)]
-    pub fn serialize(&self) -> Result<Buffer, JsError> {
-        let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
-            .map_err(JsError::from)?;
-
-        Ok(Buffer::from_bytes(bytes.as_slice()))
-    }
 }

package/src/errors/consensus/state/document/mod.rs

@@ -2,6 +2,7 @@ mod document_already_present_error;
 mod document_not_found_error;
 mod document_owner_id_mismatch_error;
 mod document_timestamp_window_violation_error;
+mod document_timestamps_are_equal_error;
 mod document_timestamps_mismatch_error;
 mod duplicate_unique_index_error;
 mod invalid_document_revision_error;
@@ -10,6 +11,7 @@ pub use document_already_present_error::*;
 pub use document_not_found_error::*;
 pub use document_owner_id_mismatch_error::*;
 pub use document_timestamp_window_violation_error::*;
+pub use document_timestamps_are_equal_error::*;
 pub use document_timestamps_mismatch_error::*;
 pub use duplicate_unique_index_error::*;
 pub use invalid_document_revision_error::*;

package/src/errors/consensus/state/identity/duplicated_identity_public_key_id_state_error.rs

@@ -2,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::identity::duplicated_identity_public_key_id_state_error::DuplicatedIdentityPublicKeyIdStateError;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DuplicatedIdentityPublicKeyIdStateError)]
@@ -38,13 +39,4 @@ impl DuplicatedIdentityPublicKeyIdStateErrorWasm {
     pub fn message(&self) -> String {
         self.inner.to_string()
     }
-
-    #[wasm_bindgen(js_name=serialize)]
-    pub fn serialize(&self) -> Result<Buffer, JsError> {
-        let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
-            .map_err(JsError::from)?;
-
-        Ok(Buffer::from_bytes(bytes.as_slice()))
-    }
 }

package/src/errors/consensus/state/identity/duplicated_identity_public_key_state_error.rs

@@ -2,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::identity::duplicated_identity_public_key_state_error::DuplicatedIdentityPublicKeyStateError;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DuplicatedIdentityPublicKeyStateError)]
@@ -35,13 +36,4 @@ impl DuplicatedIdentityPublicKeyStateErrorWasm {
     pub fn message(&self) -> String {
         self.inner.to_string()
     }
-
-    #[wasm_bindgen(js_name=serialize)]
-    pub fn serialize(&self) -> Result<Buffer, JsError> {
-        let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
-            .map_err(JsError::from)?;
-
-        Ok(Buffer::from_bytes(bytes.as_slice()))
-    }
 }

package/src/errors/consensus/state/identity/identity_already_exists_error.rs

@@ -2,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::identity::IdentityAlreadyExistsError;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=IdentityAlreadyExistsError)]
@@ -31,13 +32,4 @@ impl IdentityAlreadyExistsErrorWasm {
     pub fn message(&self) -> String {
         self.inner.to_string()
     }
-
-    #[wasm_bindgen(js_name=serialize)]
-    pub fn serialize(&self) -> Result<Buffer, JsError> {
-        let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
-            .map_err(JsError::from)?;
-
-        Ok(Buffer::from_bytes(bytes.as_slice()))
-    }
 }

package/src/errors/consensus/state/identity/identity_public_key_disabled_at_window_violation_error.rs

@@ -2,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::identity::identity_public_key_disabled_at_window_violation_error::IdentityPublicKeyDisabledAtWindowViolationError;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=IdentityPublicKeyDisabledAtWindowViolationError)]
@@ -46,13 +47,4 @@ impl IdentityPublicKeyDisabledAtWindowViolationErrorWasm {
     pub fn message(&self) -> String {
         self.inner.to_string()
     }
-
-    #[wasm_bindgen(js_name=serialize)]
-    pub fn serialize(&self) -> Result<Buffer, JsError> {
-        let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
-            .map_err(JsError::from)?;
-
-        Ok(Buffer::from_bytes(bytes.as_slice()))
-    }
 }

package/src/errors/consensus/state/identity/identity_public_key_is_disabled_error.rs

@@ -3,6 +3,7 @@ use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::identity::identity_public_key_is_disabled_error::IdentityPublicKeyIsDisabledError;
 use dpp::consensus::ConsensusError;
 use dpp::identity::KeyID;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=IdentityPublicKeyIsDisabledError)]
@@ -32,13 +33,4 @@ impl IdentityPublicKeyIsDisabledErrorWasm {
     pub fn message(&self) -> String {
         self.inner.to_string()
     }
-
-    #[wasm_bindgen(js_name=serialize)]
-    pub fn serialize(&self) -> Result<Buffer, JsError> {
-        let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
-            .map_err(JsError::from)?;
-
-        Ok(Buffer::from_bytes(bytes.as_slice()))
-    }
 }

package/src/errors/consensus/state/identity/identity_public_key_is_read_only_error.rs

@@ -3,6 +3,7 @@ use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::identity::identity_public_key_is_read_only_error::IdentityPublicKeyIsReadOnlyError;
 use dpp::consensus::ConsensusError;
 use dpp::identity::KeyID;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=IdentityPublicKeyIsReadOnlyError)]
@@ -37,13 +38,4 @@ impl IdentityPublicKeyIsReadOnlyErrorWasm {
     pub fn message(&self) -> String {
         self.inner.to_string()
     }
-
-    #[wasm_bindgen(js_name=serialize)]
-    pub fn serialize(&self) -> Result<Buffer, JsError> {
-        let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
-            .map_err(JsError::from)?;
-
-        Ok(Buffer::from_bytes(bytes.as_slice()))
-    }
 }

package/src/errors/consensus/state/identity/invalid_identity_public_key_id_error.rs

@@ -3,6 +3,8 @@ use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::identity::invalid_identity_public_key_id_error::InvalidIdentityPublicKeyIdError;
 use dpp::consensus::ConsensusError;
 use dpp::identity::KeyID;
+use dpp::serialization::{PlatformSerializable, PlatformSerializableWithPlatformVersion};
+use dpp::version::PlatformVersion;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=InvalidIdentityPublicKeyIdError)]
@@ -32,13 +34,4 @@ impl InvalidIdentityPublicKeyIdErrorWasm {
     pub fn message(&self) -> String {
         self.inner.to_string()
     }
-
-    #[wasm_bindgen(js_name=serialize)]
-    pub fn serialize(&self) -> Result<Buffer, JsError> {
-        let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
-            .map_err(JsError::from)?;
-
-        Ok(Buffer::from_bytes(bytes.as_slice()))
-    }
 }

package/src/errors/consensus/state/identity/invalid_identity_revision_error.rs

@@ -2,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::identity::invalid_identity_revision_error::InvalidIdentityRevisionError;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use js_sys::Number;
 use wasm_bindgen::prelude::*;
 
@@ -38,13 +39,4 @@ impl InvalidIdentityRevisionErrorWasm {
     pub fn message(&self) -> String {
         self.inner.to_string()
     }
-
-    #[wasm_bindgen(js_name=serialize)]
-    pub fn serialize(&self) -> Result<Buffer, JsError> {
-        let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
-            .map_err(JsError::from)?;
-
-        Ok(Buffer::from_bytes(bytes.as_slice()))
-    }
 }

package/src/errors/consensus/state/identity/max_identity_public_key_limit_reached_error.rs

@@ -2,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::identity::max_identity_public_key_limit_reached_error::MaxIdentityPublicKeyLimitReachedError;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=MaxIdentityPublicKeyLimitReachedError)]
@@ -32,13 +33,4 @@ impl MaxIdentityPublicKeyLimitReachedErrorWasm {
     pub fn message(&self) -> String {
         self.inner.to_string()
     }
-
-    #[wasm_bindgen(js_name=serialize)]
-    pub fn serialize(&self) -> Result<Buffer, JsError> {
-        let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
-            .map_err(JsError::from)?;
-
-        Ok(Buffer::from_bytes(bytes.as_slice()))
-    }
 }

package/src/errors/consensus/value_error.rs

@@ -2,6 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::basic::value_error::ValueError;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::ConsensusError;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=ValueError, inspectable)]
@@ -32,13 +33,4 @@ impl ValueErrorWasm {
     pub fn message(&self) -> String {
         self.inner.to_string()
     }
-
-    #[wasm_bindgen(js_name=serialize)]
-    pub fn serialize(&self) -> Result<Buffer, JsError> {
-        let bytes = ConsensusError::from(self.inner.clone())
-            .serialize()
-            .map_err(JsError::from)?;
-
-        Ok(Buffer::from_bytes(bytes.as_slice()))
-    }
 }

package/src/errors/from.rs

@@ -5,6 +5,7 @@ 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 crate::document::errors::from_document_to_js_error;
 use crate::errors::value_error::PlatformValueErrorWasm;
 
 use super::data_contract_not_present_error::DataContractNotPresentNotConsensusErrorWasm;
@@ -12,19 +13,20 @@ use crate::errors::consensus::consensus_error::from_consensus_error;
 
 pub fn from_dpp_err(pe: ProtocolError) -> JsValue {
     match pe {
+        // TODO(versioning): restore this
         ProtocolError::ConsensusError(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),
 
-        ProtocolError::ParsingJsonError(err) => format!(
-            "Parsing error at line {}, column {}: {}",
-            err.line(),
-            err.column(),
-            err
-        )
-        .into(),
-
+        // ProtocolError::ParsingJsonError(err) => format!(
+        //     "Parsing error at line {}, column {}: {}",
+        //     err.line(),
+        //     err.column(),
+        //     err
+        // )
+        // .into(),
+        //
         ProtocolError::DataContractNotPresentError(err) => {
             DataContractNotPresentNotConsensusErrorWasm::new(err.data_contract_id()).into()
         }
@@ -38,5 +40,7 @@ pub fn from_dpp_init_error(e: DashPlatformProtocolInitError) -> JsValue {
         DashPlatformProtocolInitError::SchemaDeserializationError(e) => e.to_string().into(),
         DashPlatformProtocolInitError::ValidationError(e) => e.to_string().into(),
         DashPlatformProtocolInitError::InvalidSchemaError(e) => e.to_string().into(),
+        // TODO(versioning): add rest erros
+        _ => JsValue::from_str(&format!("Error conversion not implemented: {e:#}",)),
     }
 }

package/src/errors/mod.rs

@@ -6,12 +6,12 @@ pub mod consensus;
 mod from;
 mod js_conversion;
 pub mod protocol_error;
-mod public_key_validation_error;
-
-pub use public_key_validation_error::*;
-
-mod compatible_protocol_version_is_not_defined_error;
+// mod public_key_validation_error;
+//
+// pub use public_key_validation_error::*;
+//
+// mod compatible_protocol_version_is_not_defined_error;
 pub mod data_contract_not_present_error;
-pub mod dpp_error;
+// pub mod dpp_error;
 pub mod value_error;
-pub use compatible_protocol_version_is_not_defined_error::*;
+// pub use compatible_protocol_version_is_not_defined_error::*;

package/src/errors/value_error.rs

@@ -29,4 +29,9 @@ impl PlatformValueErrorWasm {
     pub fn to_string(&self) -> String {
         format!("PlatformValueError: {}", self.message)
     }
+
+    #[wasm_bindgen(js_name=valueOf)]
+    pub fn value_of(&self) -> String {
+        self.to_string()
+    }
 }

package/src/identity/errors/asset_lock_transaction_is_not_found_error.rs

@@ -1,4 +1,3 @@
-use dpp::dashcore::hashes::hex::ToHex;
 use dpp::identity::errors::AssetLockTransactionIsNotFoundError;
 use wasm_bindgen::prelude::*;
 
@@ -15,6 +14,6 @@ impl From<&AssetLockTransactionIsNotFoundError> for AssetLockTransactionIsNotFou
 impl AssetLockTransactionIsNotFoundErrorWasm {
     #[wasm_bindgen(js_name=getTransactionId)]
     pub fn transaction_id(&self) -> JsValue {
-        self.0.transaction_id().to_hex().into()
+        hex::encode(self.0.transaction_id()).into()
     }
 }

package/src/identity/factory_utils.rs

@@ -1,32 +1,32 @@
 use crate::errors::RustConversionError;
-use crate::identity::identity_public_key_transitions::IdentityPublicKeyWithWitnessWasm;
+use crate::identity::state_transition::create_asset_lock_proof_from_wasm_instance;
+use crate::identity::state_transition::identity_public_key_transitions::IdentityPublicKeyWithWitnessWasm;
+use crate::identity::IdentityPublicKeyWasm;
 use crate::utils::{generic_of_js_val, to_vec_of_platform_values};
-use crate::{create_asset_lock_proof_from_wasm_instance, IdentityPublicKeyWasm};
+use dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV0;
 use dpp::identity::state_transition::asset_lock_proof::AssetLockProof;
-use dpp::identity::state_transition::identity_public_key_transitions::IdentityPublicKeyInCreationWithWitness;
 use dpp::identity::{IdentityPublicKey, KeyID};
+use dpp::serialization::ValueConvertible;
+use dpp::state_transition::public_key_in_creation::IdentityPublicKeyInCreation;
 use std::collections::BTreeMap;
 use wasm_bindgen::__rt::Ref;
 use wasm_bindgen::{JsCast, JsValue};
 
-pub fn parse_create_args(
-    asset_lock_proof: JsValue,
+pub fn parse_public_keys(
     public_keys: js_sys::Array,
-) -> Result<(AssetLockProof, BTreeMap<KeyID, IdentityPublicKey>), JsValue> {
-    let asset_lock_proof = create_asset_lock_proof_from_wasm_instance(&asset_lock_proof)?;
-
+) -> Result<BTreeMap<KeyID, IdentityPublicKey>, JsValue> {
     let raw_public_keys = to_vec_of_platform_values(public_keys.iter())?;
 
     let public_keys = raw_public_keys
         .into_iter()
-        .map(|v| IdentityPublicKey::from_value(v).map(|key| (key.id, key)))
+        .map(|v| IdentityPublicKey::from_object(v).map(|key| (key.id(), key)))
         .collect::<Result<_, _>>()
         .map_err(|e| format!("converting to collection of IdentityPublicKeys failed: {e:#}"))?;
 
-    Ok((asset_lock_proof, public_keys))
+    Ok(public_keys)
 }
 
-type AddPublicKeys = Option<Vec<IdentityPublicKeyInCreationWithWitness>>;
+type AddPublicKeys = Option<Vec<IdentityPublicKeyInCreation>>;
 type DisablePublicKeys = Option<Vec<KeyID>>;
 
 pub fn parse_create_identity_update_transition_keys(
@@ -44,7 +44,7 @@ pub fn parse_create_identity_update_transition_keys(
                     .to_js_value()
             })?;
 
-        let keys: Vec<IdentityPublicKeyInCreationWithWitness> = add_public_keys_array
+        let keys: Vec<IdentityPublicKeyInCreation> = add_public_keys_array
             .iter()
             .map(|key| {
                 let public_key: Ref<IdentityPublicKeyWithWitnessWasm> =
@@ -55,7 +55,7 @@ pub fn parse_create_identity_update_transition_keys(
 
                 Ok(public_key.clone().into())
             })
-            .collect::<Result<Vec<IdentityPublicKeyInCreationWithWitness>, JsValue>>()?;
+            .collect::<Result<Vec<IdentityPublicKeyInCreation>, JsValue>>()?;
 
         add_public_keys = Some(keys)
     }