@dashevo/wasm-dpp 0.25.0-dev.15 → 0.25.0-dev.17

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

@@ -2,7 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::document::document_already_present_error::DocumentAlreadyPresentError;
 use dpp::consensus::ConsensusError;
-use dpp::serialization_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DocumentAlreadyPresentError)]
@@ -32,13 +32,4 @@ impl DocumentAlreadyPresentErrorWasm {
     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_not_found_error.rs

@@ -2,7 +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_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DocumentNotFoundError)]
@@ -32,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,7 +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_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DocumentOwnerIdMismatchError)]
@@ -42,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,7 +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_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DocumentTimestampWindowViolationError)]
@@ -58,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

@@ -2,7 +2,7 @@ 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_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DocumentTimestampsAreEqualError)]
@@ -31,13 +31,4 @@ impl DocumentTimestampsAreEqualErrorWasm {
     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(|e| JsError::from(e))?;
-
-        Ok(Buffer::from_bytes(bytes.as_slice()))
-    }
 }

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

@@ -2,7 +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_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DocumentTimestampsMismatchError)]
@@ -31,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,7 +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_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use js_sys::JsString;
 use wasm_bindgen::prelude::*;
 
@@ -42,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,7 +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_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=InvalidDocumentRevisionError)]
@@ -24,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)]
@@ -38,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/identity/duplicated_identity_public_key_id_state_error.rs

@@ -2,7 +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_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DuplicatedIdentityPublicKeyIdStateError)]
@@ -39,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,7 +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_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=DuplicatedIdentityPublicKeyStateError)]
@@ -36,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,7 +2,7 @@ use crate::buffer::Buffer;
 use dpp::consensus::codes::ErrorWithCode;
 use dpp::consensus::state::identity::IdentityAlreadyExistsError;
 use dpp::consensus::ConsensusError;
-use dpp::serialization_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=IdentityAlreadyExistsError)]
@@ -32,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,7 +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_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=IdentityPublicKeyDisabledAtWindowViolationError)]
@@ -47,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,7 +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_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=IdentityPublicKeyIsDisabledError)]
@@ -33,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,7 +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_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=IdentityPublicKeyIsReadOnlyError)]
@@ -38,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,7 +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_traits::PlatformSerializable;
+use dpp::serialization::{PlatformSerializable, PlatformSerializableWithPlatformVersion};
+use dpp::version::PlatformVersion;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=InvalidIdentityPublicKeyIdError)]
@@ -33,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,7 +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_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use js_sys::Number;
 use wasm_bindgen::prelude::*;
 
@@ -39,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,7 +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_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=MaxIdentityPublicKeyLimitReachedError)]
@@ -33,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,7 +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_traits::PlatformSerializable;
+use dpp::serialization::PlatformSerializable;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=ValueError, inspectable)]
@@ -33,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/identity/factory_utils.rs

@@ -1,29 +1,29 @@
 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::IdentityPublicKeyInCreation;
 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<IdentityPublicKeyInCreation>>;