@dashevo/wasm-dpp 0.23.0-dev.14 → 0.24.0-dev.10

package/src/errors/consensus/state/data_contract/data_trigger/data_trigger_condition_error.rs

@@ -0,0 +1,74 @@
+use crate::buffer::Buffer;
+use crate::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
+
+use dpp::identifier::Identifier;
+use dpp::prelude::DocumentTransition;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=DataTriggerConditionError)]
+pub struct DataTriggerConditionErrorWasm {
+    data_contract_id: Identifier,
+    document_transition_id: Identifier,
+    message: String,
+    document_transition: Option<DocumentTransition>,
+    owner_id: Option<Identifier>,
+    code: u32,
+}
+
+#[wasm_bindgen(js_class=DataTriggerConditionError)]
+impl DataTriggerConditionErrorWasm {
+    #[wasm_bindgen(js_name=getDataContractId)]
+    pub fn data_contract_id(&self) -> Buffer {
+        Buffer::from_bytes(self.data_contract_id.as_bytes())
+    }
+
+    #[wasm_bindgen(js_name=getDocumentTransitionId)]
+    pub fn document_transition_id(&self) -> Buffer {
+        Buffer::from_bytes(self.document_transition_id.as_bytes())
+    }
+
+    #[wasm_bindgen(js_name=getMessage)]
+    pub fn message(&self) -> String {
+        self.message.clone()
+    }
+
+    #[wasm_bindgen(js_name=getTimestamp)]
+    pub fn document_transition(&self) -> JsValue {
+        if let Some(document_transition) = &self.document_transition {
+            from_document_transition_to_js_value(document_transition.clone())
+        } else {
+            JsValue::undefined()
+        }
+    }
+
+    #[wasm_bindgen(js_name=getOwnerId)]
+    pub fn owner_id(&self) -> Option<Buffer> {
+        let owner_id = self.owner_id.as_ref()?;
+        Some(Buffer::from_bytes(owner_id.as_bytes()))
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}
+
+impl DataTriggerConditionErrorWasm {
+    pub fn new(
+        data_contract_id: Identifier,
+        document_transition_id: Identifier,
+        message: String,
+        document_transition: Option<DocumentTransition>,
+        owner_id: Option<Identifier>,
+        code: u32,
+    ) -> Self {
+        Self {
+            data_contract_id,
+            document_transition_id,
+            message,
+            document_transition,
+            owner_id,
+            code,
+        }
+    }
+}

package/src/errors/consensus/state/data_contract/data_trigger/data_trigger_execution_error.rs

@@ -0,0 +1,82 @@
+use crate::buffer::Buffer;
+use crate::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
+
+use dpp::identifier::Identifier;
+use dpp::prelude::DocumentTransition;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=DataTriggerExecutionError)]
+pub struct DataTriggerExecutionErrorWasm {
+    data_contract_id: Identifier,
+    document_transition_id: Identifier,
+    message: String,
+    execution_error: JsError,
+    document_transition: Option<DocumentTransition>,
+    owner_id: Option<Identifier>,
+    code: u32,
+}
+
+#[wasm_bindgen(js_class=DataTriggerExecutionError)]
+impl DataTriggerExecutionErrorWasm {
+    #[wasm_bindgen(js_name=getDataContractId)]
+    pub fn data_contract_id(&self) -> Buffer {
+        Buffer::from_bytes(self.data_contract_id.as_bytes())
+    }
+
+    #[wasm_bindgen(js_name=getExecutionError)]
+    pub fn data_execution_error(&self) -> JsError {
+        self.execution_error.clone()
+    }
+
+    #[wasm_bindgen(js_name=getDocumentTransitionId)]
+    pub fn document_transition_id(&self) -> Buffer {
+        Buffer::from_bytes(self.document_transition_id.as_bytes())
+    }
+
+    #[wasm_bindgen(js_name=getMessage)]
+    pub fn message(&self) -> String {
+        self.message.clone()
+    }
+
+    #[wasm_bindgen(js_name=getTimestamp)]
+    pub fn document_transition(&self) -> JsValue {
+        if let Some(document_transition) = &self.document_transition {
+            from_document_transition_to_js_value(document_transition.clone())
+        } else {
+            JsValue::undefined()
+        }
+    }
+
+    #[wasm_bindgen(js_name=getOwnerId)]
+    pub fn owner_id(&self) -> Option<Buffer> {
+        let owner_id = self.owner_id.as_ref()?;
+        Some(Buffer::from_bytes(owner_id.as_bytes()))
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}
+
+impl DataTriggerExecutionErrorWasm {
+    pub fn new(
+        data_contract_id: Identifier,
+        document_transition_id: Identifier,
+        message: String,
+        execution_error: wasm_bindgen::JsError,
+        document_transition: Option<DocumentTransition>,
+        owner_id: Option<Identifier>,
+        code: u32,
+    ) -> Self {
+        Self {
+            data_contract_id,
+            document_transition_id,
+            message,
+            execution_error,
+            document_transition,
+            owner_id,
+            code,
+        }
+    }
+}

package/src/errors/consensus/state/data_contract/data_trigger/data_trigger_invalid_result_error.rs

@@ -0,0 +1,66 @@
+use crate::buffer::Buffer;
+use crate::state_transition::document_batch_transition::document_transition::from_document_transition_to_js_value;
+
+use dpp::identifier::Identifier;
+use dpp::prelude::DocumentTransition;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=DataTriggerInvalidResultError)]
+pub struct DataTriggerInvalidResultErrorWasm {
+    data_contract_id: Identifier,
+    document_transition_id: Identifier,
+    document_transition: Option<DocumentTransition>,
+    owner_id: Option<Identifier>,
+    code: u32,
+}
+
+#[wasm_bindgen(js_class=DataTriggerInvalidResultError)]
+impl DataTriggerInvalidResultErrorWasm {
+    #[wasm_bindgen(js_name=getDataContractId)]
+    pub fn data_contract_id(&self) -> Buffer {
+        Buffer::from_bytes(self.data_contract_id.as_bytes())
+    }
+
+    #[wasm_bindgen(js_name=getDocumentTransitionId)]
+    pub fn document_transition_id(&self) -> Buffer {
+        Buffer::from_bytes(self.document_transition_id.as_bytes())
+    }
+
+    #[wasm_bindgen(js_name=getTimestamp)]
+    pub fn document_transition(&self) -> JsValue {
+        if let Some(document_transition) = &self.document_transition {
+            from_document_transition_to_js_value(document_transition.clone())
+        } else {
+            JsValue::undefined()
+        }
+    }
+
+    #[wasm_bindgen(js_name=getOwnerId)]
+    pub fn owner_id(&self) -> Option<Buffer> {
+        let owner_id = self.owner_id.as_ref()?;
+        Some(Buffer::from_bytes(owner_id.as_bytes()))
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}
+
+impl DataTriggerInvalidResultErrorWasm {
+    pub fn new(
+        data_contract_id: Identifier,
+        document_transition_id: Identifier,
+        document_transition: Option<DocumentTransition>,
+        owner_id: Option<Identifier>,
+        code: u32,
+    ) -> Self {
+        Self {
+            data_contract_id,
+            document_transition_id,
+            document_transition,
+            owner_id,
+            code,
+        }
+    }
+}

package/src/errors/consensus/state/data_contract/data_trigger/mod.rs

@@ -0,0 +1,7 @@
+mod data_trigger_condition_error;
+mod data_trigger_execution_error;
+mod data_trigger_invalid_result_error;
+
+pub use data_trigger_condition_error::*;
+pub use data_trigger_execution_error::*;
+pub use data_trigger_invalid_result_error::*;

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

@@ -0,0 +1,4 @@
+mod data_contract_already_present_error;
+pub mod data_trigger;
+
+pub use data_contract_already_present_error::*;

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

@@ -0,0 +1,28 @@
+use crate::buffer::Buffer;
+use dpp::identifier::Identifier;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=DocumentAlreadyPresentError)]
+pub struct DocumentAlreadyPresentErrorWasm {
+    document_id: Identifier,
+    code: u32,
+}
+
+#[wasm_bindgen(js_class=DocumentAlreadyPresentError)]
+impl DocumentAlreadyPresentErrorWasm {
+    #[wasm_bindgen(js_name=getDocumentId)]
+    pub fn document_id(&self) -> Buffer {
+        Buffer::from_bytes(self.document_id.as_bytes())
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}
+
+impl DocumentAlreadyPresentErrorWasm {
+    pub fn new(document_id: Identifier, code: u32) -> Self {
+        Self { document_id, code }
+    }
+}

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

@@ -0,0 +1,28 @@
+use crate::buffer::Buffer;
+use dpp::identifier::Identifier;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=DocumentNotFoundError)]
+pub struct DocumentNotFoundErrorWasm {
+    document_id: Identifier,
+    code: u32,
+}
+
+#[wasm_bindgen(js_class=DocumentNotFoundError)]
+impl DocumentNotFoundErrorWasm {
+    #[wasm_bindgen(js_name=getDocumentId)]
+    pub fn document_id(&self) -> Buffer {
+        Buffer::from_bytes(self.document_id.as_bytes())
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}
+
+impl DocumentNotFoundErrorWasm {
+    pub fn new(document_id: Identifier, code: u32) -> Self {
+        Self { document_id, code }
+    }
+}

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

@@ -0,0 +1,50 @@
+use crate::buffer::Buffer;
+use dpp::identifier::Identifier;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=DocumentOwnerIdMismatchError)]
+pub struct DocumentOwnerIdMismatchErrorWasm {
+    document_id: Identifier,
+    document_owner_id: Identifier,
+    existing_document_owner_id: Identifier,
+    code: u32,
+}
+
+#[wasm_bindgen(js_class=DocumentOwnerIdMismatchError)]
+impl DocumentOwnerIdMismatchErrorWasm {
+    #[wasm_bindgen(js_name=getDocumentId)]
+    pub fn document_id(&self) -> Buffer {
+        Buffer::from_bytes(self.document_id.as_bytes())
+    }
+
+    #[wasm_bindgen(js_name=getDocumentOwnerId)]
+    pub fn document_owner_id(&self) -> Buffer {
+        Buffer::from_bytes(self.document_owner_id.as_bytes())
+    }
+
+    #[wasm_bindgen(js_name=getExistingDocumentOwnerId)]
+    pub fn existing_document_owner_id(&self) -> Buffer {
+        Buffer::from_bytes(self.existing_document_owner_id.as_bytes())
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}
+
+impl DocumentOwnerIdMismatchErrorWasm {
+    pub fn new(
+        document_id: Identifier,
+        document_owner_id: Identifier,
+        existing_document_owner_id: Identifier,
+        code: u32,
+    ) -> Self {
+        Self {
+            document_id,
+            document_owner_id,
+            existing_document_owner_id,
+            code,
+        }
+    }
+}

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

@@ -0,0 +1,72 @@
+use crate::buffer::Buffer;
+use dpp::identifier::Identifier;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=DocumentTimestampWindowViolationError)]
+pub struct DocumentTimestampWindowViolationErrorWasm {
+    timestamp_name: String,
+    document_id: Identifier,
+    timestamp: i64,
+    time_window_start: i64,
+    time_window_end: i64,
+    code: u32,
+}
+
+#[wasm_bindgen(js_class=DocumentTimestampWindowViolationError)]
+impl DocumentTimestampWindowViolationErrorWasm {
+    #[wasm_bindgen(js_name=getDocumentId)]
+    pub fn document_id(&self) -> Buffer {
+        Buffer::from_bytes(self.document_id.as_bytes())
+    }
+
+    #[wasm_bindgen(js_name=getTimestampName)]
+    pub fn timestamp_name(&self) -> String {
+        self.timestamp_name.clone()
+    }
+
+    #[wasm_bindgen(js_name=getTimestamp)]
+    pub fn timestamp(&self) -> js_sys::Date {
+        // TODO: Figure out how to match rust timestamps with JS timestamps
+        let timestamp = JsValue::from(self.timestamp as u32);
+        js_sys::Date::new(&timestamp)
+    }
+
+    #[wasm_bindgen(js_name=getTimeWindowStart)]
+    pub fn time_window_start(&self) -> js_sys::Date {
+        // TODO: Figure out how to match rust timestamps with JS timestamps
+        let timestamp = JsValue::from(self.time_window_start as u32);
+        js_sys::Date::new(&timestamp)
+    }
+
+    #[wasm_bindgen(js_name=getTimeWindowEnd)]
+    pub fn time_window_end(&self) -> js_sys::Date {
+        // TODO: Figure out how to match rust timestamps with JS timestamps
+        let timestamp = JsValue::from(self.time_window_end as u32);
+        js_sys::Date::new(&timestamp)
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}
+
+impl DocumentTimestampWindowViolationErrorWasm {
+    pub fn new(
+        timestamp_name: String,
+        document_id: Identifier,
+        timestamp: i64,
+        time_window_start: i64,
+        time_window_end: i64,
+        code: u32,
+    ) -> Self {
+        Self {
+            timestamp_name,
+            document_id,
+            timestamp,
+            time_window_start,
+            time_window_end,
+            code,
+        }
+    }
+}

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

@@ -0,0 +1,28 @@
+use crate::buffer::Buffer;
+use dpp::identifier::Identifier;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=DocumentTimestampsMismatchError)]
+pub struct DocumentTimestampsMismatchErrorWasm {
+    document_id: Identifier,
+    code: u32,
+}
+
+#[wasm_bindgen(js_class=DocumentTimestampsMismatchError)]
+impl DocumentTimestampsMismatchErrorWasm {
+    #[wasm_bindgen(js_name=getDocumentId)]
+    pub fn document_id(&self) -> Buffer {
+        Buffer::from_bytes(self.document_id.as_bytes())
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}
+
+impl DocumentTimestampsMismatchErrorWasm {
+    pub fn new(document_id: Identifier, code: u32) -> Self {
+        Self { document_id, code }
+    }
+}

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

@@ -0,0 +1,42 @@
+use crate::buffer::Buffer;
+use dpp::identifier::Identifier;
+use js_sys::JsString;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=DuplicateUniqueIndexError)]
+pub struct DuplicateUniqueIndexErrorWasm {
+    document_id: Identifier,
+    duplicating_properties: Vec<String>,
+    code: u32,
+}
+
+#[wasm_bindgen(js_class=DuplicateUniqueIndexError)]
+impl DuplicateUniqueIndexErrorWasm {
+    #[wasm_bindgen(js_name=getDocumentId)]
+    pub fn document_id(&self) -> Buffer {
+        Buffer::from_bytes(self.document_id.as_bytes())
+    }
+
+    #[wasm_bindgen(js_name=getDuplicatingProperties)]
+    pub fn duplicating_properties(&self) -> js_sys::Array {
+        self.duplicating_properties
+            .iter()
+            .map(|string| JsString::from(string.as_ref()))
+            .collect()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}
+
+impl DuplicateUniqueIndexErrorWasm {
+    pub fn new(document_id: Identifier, duplicating_properties: Vec<String>, code: u32) -> Self {
+        Self {
+            document_id,
+            duplicating_properties,
+            code,
+        }
+    }
+}

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

@@ -0,0 +1,38 @@
+use crate::buffer::Buffer;
+use dpp::identifier::Identifier;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=InvalidDocumentRevisionError)]
+pub struct InvalidDocumentRevisionErrorWasm {
+    document_id: Identifier,
+    current_revision: u32,
+    code: u32,
+}
+
+#[wasm_bindgen(js_class=InvalidDocumentRevisionError)]
+impl InvalidDocumentRevisionErrorWasm {
+    #[wasm_bindgen(js_name=getDocumentId)]
+    pub fn document_id(&self) -> Buffer {
+        Buffer::from_bytes(self.document_id.as_bytes())
+    }
+
+    #[wasm_bindgen(js_name=getCurrentRevision)]
+    pub fn current_revision(&self) -> u32 {
+        self.current_revision
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}
+
+impl InvalidDocumentRevisionErrorWasm {
+    pub fn new(document_id: Identifier, current_revision: u32, code: u32) -> Self {
+        Self {
+            document_id,
+            current_revision,
+            code,
+        }
+    }
+}

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

@@ -0,0 +1,15 @@
+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_mismatch_error;
+mod duplicate_unique_index_error;
+mod invalid_document_revision_error;
+
+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_mismatch_error::*;
+pub use duplicate_unique_index_error::*;
+pub use invalid_document_revision_error::*;

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

@@ -0,0 +1,28 @@
+use crate::buffer::Buffer;
+use dpp::consensus::state::identity::IdentityAlreadyExistsError;
+use dpp::consensus::ConsensusError;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=IdentityAlreadyExistsError)]
+pub struct IdentityAlreadyExistsErrorWasm {
+    inner: IdentityAlreadyExistsError,
+}
+
+impl From<&IdentityAlreadyExistsError> for IdentityAlreadyExistsErrorWasm {
+    fn from(e: &IdentityAlreadyExistsError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+
+#[wasm_bindgen(js_class=IdentityAlreadyExistsError)]
+impl IdentityAlreadyExistsErrorWasm {
+    #[wasm_bindgen(js_name=getIdentityId)]
+    pub fn identity_id(&self) -> Buffer {
+        Buffer::from_bytes(self.inner.identity_id())
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        ConsensusError::from(self.inner.clone()).code()
+    }
+}

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

@@ -0,0 +1,49 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=IdentityPublicKeyDisabledAtWindowViolationError)]
+pub struct IdentityPublicKeyDisabledAtWindowViolationErrorWasm {
+    disabled_at: u64,
+    time_window_start: u64,
+    time_window_end: u64,
+    code: u32,
+}
+
+#[wasm_bindgen(js_class=IdentityPublicKeyDisabledAtWindowViolationError)]
+impl IdentityPublicKeyDisabledAtWindowViolationErrorWasm {
+    #[wasm_bindgen(js_name=getDisabledAt)]
+    pub fn disabled_at(&self) -> js_sys::Date {
+        // TODO: Figure out how to match rust timestamps with JS timestamps
+        let timestamp = JsValue::from(self.disabled_at as u32);
+        js_sys::Date::new(&timestamp)
+    }
+
+    #[wasm_bindgen(js_name=getTimeWindowStart)]
+    pub fn time_window_start(&self) -> js_sys::Date {
+        // TODO: Figure out how to match rust timestamps with JS timestamps
+        let timestamp = JsValue::from(self.time_window_start as u32);
+        js_sys::Date::new(&timestamp)
+    }
+
+    #[wasm_bindgen(js_name=getTimeWindowEnd)]
+    pub fn time_window_end(&self) -> js_sys::Date {
+        // TODO: Figure out how to match rust timestamps with JS timestamps
+        let timestamp = JsValue::from(self.time_window_end as u32);
+        js_sys::Date::new(&timestamp)
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}
+
+impl IdentityPublicKeyDisabledAtWindowViolationErrorWasm {
+    pub fn new(disabled_at: u64, time_window_start: u64, time_window_end: u64, code: u32) -> Self {
+        Self {
+            disabled_at,
+            time_window_start,
+            time_window_end,
+            code,
+        }
+    }
+}

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

@@ -0,0 +1,31 @@
+use dpp::identity::KeyID;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=IdentityPublicKeyIsDisabledError)]
+pub struct IdentityPublicKeyIsDisabledErrorWasm {
+    public_key_index: KeyID,
+    code: u32,
+}
+
+#[wasm_bindgen(js_class=IdentityPublicKeyIsDisabledError)]
+impl IdentityPublicKeyIsDisabledErrorWasm {
+    #[wasm_bindgen(js_name=getPublicKeyIndex)]
+    pub fn public_key_index(&self) -> u32 {
+        // TODO: make key ids u32?
+        self.public_key_index as u32
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}
+
+impl IdentityPublicKeyIsDisabledErrorWasm {
+    pub fn new(public_key_index: KeyID, code: u32) -> Self {
+        Self {
+            public_key_index,
+            code,
+        }
+    }
+}

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

@@ -0,0 +1,28 @@
+use dpp::identity::KeyID;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=IdentityPublicKeyIsReadOnlyError)]
+pub struct IdentityPublicKeyIsReadOnlyErrorWasm {
+    key_id: KeyID,
+    code: u32,
+}
+
+#[wasm_bindgen(js_class=IdentityPublicKeyIsReadOnlyError)]
+impl IdentityPublicKeyIsReadOnlyErrorWasm {
+    #[wasm_bindgen(js_name=getKeyId)]
+    pub fn key_id(&self) -> u32 {
+        // TODO: make key ids u32?
+        self.key_id as u32
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}
+
+impl IdentityPublicKeyIsReadOnlyErrorWasm {
+    pub fn new(key_id: KeyID, code: u32) -> Self {
+        Self { key_id, code }
+    }
+}