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

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

@@ -0,0 +1,274 @@
+use dpp::errors::consensus::basic::JsonSchemaError;
+use serde::Serialize;
+use serde_json::Value;
+use std::ops::Deref;
+
+use dpp::jsonschema::error::{TypeKind, ValidationErrorKind};
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=JsonSchemaError)]
+pub struct JsonSchemaErrorWasm {
+    keyword: String,
+    instance_path: String,
+    schema_path: String,
+    params: Value,
+    property_name: String,
+    code: u32,
+}
+
+#[derive(Default)]
+struct Params {
+    pub keyword: String,
+    pub params: serde_json::Map<String, Value>,
+    pub property_name: String,
+}
+
+pub struct ParamsBuilder {
+    kek: Params,
+}
+
+impl ParamsBuilder {
+    fn new() -> Self {
+        Self {
+            kek: Params::default(),
+        }
+    }
+
+    fn set_keyword(mut self, keyword: impl Into<String>) -> Self {
+        self.kek.keyword = keyword.into();
+        self
+    }
+
+    fn set_property_name(mut self, property_name: impl Into<String>) -> Self {
+        self.kek.property_name = property_name.into();
+        self
+    }
+
+    fn add_param(mut self, key: impl Into<String>, value: Value) -> Self {
+        self.kek.params.insert(key.into(), value);
+        self
+    }
+
+    fn build(self) -> Params {
+        self.kek
+    }
+}
+
+impl From<&ValidationErrorKind> for Params {
+    fn from(validation_error_kind: &ValidationErrorKind) -> Self {
+        match validation_error_kind {
+            ValidationErrorKind::Required { property } => ParamsBuilder::new()
+                .set_keyword("required")
+                .set_property_name(property.to_string())
+                .add_param("missingProperty", property.clone())
+                .build(),
+            ValidationErrorKind::AdditionalItems { limit } => ParamsBuilder::new()
+                .set_keyword("additionalItems")
+                .add_param("maxItems", Value::from(*limit))
+                .build(),
+            ValidationErrorKind::AdditionalProperties { unexpected } => ParamsBuilder::new()
+                .set_keyword("additionalProperties")
+                .add_param("additionalProperties", unexpected.clone().into())
+                .build(),
+            ValidationErrorKind::AnyOf => ParamsBuilder::new().set_keyword("anyOf").build(),
+            ValidationErrorKind::BacktrackLimitExceeded { .. } => ParamsBuilder::new()
+                .set_keyword("backtrackLimitExceeded")
+                .build(),
+            ValidationErrorKind::Constant { expected_value } => ParamsBuilder::new()
+                .set_keyword("const")
+                .add_param("allowedValue", expected_value.clone())
+                .build(),
+            ValidationErrorKind::Contains => ParamsBuilder::new().set_keyword("contains").build(),
+            ValidationErrorKind::ContentEncoding { content_encoding } => ParamsBuilder::new()
+                .set_keyword("contentEncoding")
+                .add_param("contentEncoding", content_encoding.clone().into())
+                .build(),
+            ValidationErrorKind::ContentMediaType { content_media_type } => ParamsBuilder::new()
+                .set_keyword("contentMediaType")
+                .add_param("contentMediaType", content_media_type.clone().into())
+                .build(),
+            ValidationErrorKind::Enum { options } => ParamsBuilder::new()
+                .set_keyword("enum")
+                .add_param("enum", options.clone())
+                .build(),
+            ValidationErrorKind::ExclusiveMaximum { limit } => ParamsBuilder::new()
+                .set_keyword("exclusiveMaximum")
+                .add_param("exclusiveMaximum", limit.clone())
+                .build(),
+            ValidationErrorKind::ExclusiveMinimum { limit } => ParamsBuilder::new()
+                .set_keyword("exclusiveMinimum")
+                .add_param("exclusiveMinimum", limit.clone())
+                .build(),
+            ValidationErrorKind::FalseSchema => {
+                ParamsBuilder::new().set_keyword("falseSchema").build()
+            }
+            ValidationErrorKind::FileNotFound { .. } => {
+                ParamsBuilder::new().set_keyword("fileNotFound").build()
+            }
+            ValidationErrorKind::Format { format } => ParamsBuilder::new()
+                .set_keyword("format")
+                .add_param("format", format.to_string().into())
+                .build(),
+            ValidationErrorKind::FromUtf8 { .. } => {
+                ParamsBuilder::new().set_keyword("fromUtf8").build()
+            }
+            ValidationErrorKind::Utf8 { .. } => ParamsBuilder::new().set_keyword("utf8").build(),
+            ValidationErrorKind::JSONParse { .. } => {
+                ParamsBuilder::new().set_keyword("JSONParse").build()
+            }
+            ValidationErrorKind::InvalidReference { reference } => ParamsBuilder::new()
+                .set_keyword("invalidReference")
+                .add_param("invalidReference", reference.clone().into())
+                .build(),
+            ValidationErrorKind::InvalidURL { .. } => {
+                ParamsBuilder::new().set_keyword("invalidURL").build()
+            }
+            ValidationErrorKind::MaxItems { limit } => ParamsBuilder::new()
+                .set_keyword("maxItems")
+                .add_param("maxItems", Value::from(*limit))
+                .build(),
+            ValidationErrorKind::Maximum { limit } => ParamsBuilder::new()
+                .set_keyword("maximum")
+                .add_param("maximum", limit.clone())
+                .build(),
+            ValidationErrorKind::MaxLength { limit } => ParamsBuilder::new()
+                .set_keyword("maxLength")
+                .add_param("maxLength", Value::from(*limit))
+                .build(),
+            ValidationErrorKind::MaxProperties { limit } => ParamsBuilder::new()
+                .set_keyword("maxProperties")
+                .add_param("maxProperties", Value::from(*limit))
+                .build(),
+            ValidationErrorKind::MinItems { limit } => ParamsBuilder::new()
+                .set_keyword("minItems")
+                .add_param("maximum", Value::from(*limit))
+                .build(),
+            ValidationErrorKind::Minimum { limit } => ParamsBuilder::new()
+                .set_keyword("minimum")
+                .add_param("minimum", limit.clone())
+                .build(),
+            ValidationErrorKind::MinLength { limit } => ParamsBuilder::new()
+                .set_keyword("minLength")
+                .add_param("minLength", Value::from(*limit))
+                .build(),
+            ValidationErrorKind::MinProperties { limit } => ParamsBuilder::new()
+                .set_keyword("minProperties")
+                .add_param("minProperties", Value::from(*limit))
+                .build(),
+            ValidationErrorKind::MultipleOf { multiple_of } => ParamsBuilder::new()
+                .set_keyword("multipleOf")
+                .add_param("multipleOf", Value::from(*multiple_of))
+                .build(),
+            ValidationErrorKind::Not { schema } => ParamsBuilder::new()
+                .set_keyword("not")
+                .add_param("not", schema.clone())
+                .build(),
+            ValidationErrorKind::OneOfMultipleValid => ParamsBuilder::new()
+                .set_keyword("oneOfMultipleValid")
+                .build(),
+            ValidationErrorKind::OneOfNotValid => {
+                ParamsBuilder::new().set_keyword("oneOfNotValid").build()
+            }
+            ValidationErrorKind::Pattern { pattern } => ParamsBuilder::new()
+                .set_keyword("pattern")
+                .add_param("pattern", pattern.clone().into())
+                .build(),
+            ValidationErrorKind::PropertyNames { error } => {
+                let Params {
+                    keyword,
+                    params,
+                    property_name,
+                } = Params::from(&error.kind);
+
+                ParamsBuilder::new()
+                    .set_keyword("propertyNames")
+                    .add_param("instancePath", error.instance_path.to_string().into())
+                    .add_param("schemaPath", error.schema_path.to_string().into())
+                    .add_param("instance", error.instance.deref().clone())
+                    .add_param("params", params.into())
+                    .add_param("keyword", keyword.into())
+                    .add_param("propertyName", property_name.into())
+                    .build()
+            }
+            ValidationErrorKind::Schema => ParamsBuilder::new().set_keyword("schema").build(),
+            ValidationErrorKind::Type { kind } => {
+                let val: Value = match kind {
+                    TypeKind::Single(single) => single.to_string().into(),
+                    TypeKind::Multiple(multiple) => multiple
+                        .into_iter()
+                        .map(|single| Value::from(single.to_string()))
+                        .collect::<Vec<Value>>()
+                        .into(),
+                };
+                ParamsBuilder::new()
+                    .set_keyword("type")
+                    .add_param("type", val)
+                    .build()
+            }
+            ValidationErrorKind::UniqueItems => {
+                ParamsBuilder::new().set_keyword("uniqueItems").build()
+            }
+            ValidationErrorKind::UnknownReferenceScheme { scheme } => ParamsBuilder::new()
+                .set_keyword("unknownReferenceScheme")
+                .add_param("unknownReferenceScheme", scheme.clone().into())
+                .build(),
+            ValidationErrorKind::Resolver { url, error: _ } => ParamsBuilder::new()
+                .set_keyword("resolver")
+                .add_param("url", url.to_string().into())
+                .build(),
+        }
+    }
+}
+
+impl JsonSchemaErrorWasm {
+    pub fn new(e: &JsonSchemaError, code: u32) -> Self {
+        let Params {
+            keyword,
+            params,
+            property_name,
+        } = Params::from(e.kind());
+
+        Self {
+            keyword,
+            instance_path: e.instance_path().to_string(),
+            schema_path: e.schema_path().to_string(),
+            params: Value::Object(params),
+            property_name,
+            code,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=JsonSchemaError)]
+impl JsonSchemaErrorWasm {
+    #[wasm_bindgen(js_name=getKeyword)]
+    pub fn keyword(&self) -> String {
+        self.keyword.clone()
+    }
+
+    #[wasm_bindgen(js_name=getInstancePath)]
+    pub fn instance_path(&self) -> String {
+        self.instance_path.clone()
+    }
+
+    #[wasm_bindgen(js_name=getSchemaPath)]
+    pub fn schema_path(&self) -> String {
+        self.schema_path.clone()
+    }
+
+    #[wasm_bindgen(js_name=getPropertyName)]
+    pub fn property_name(&self) -> String {
+        self.property_name.clone()
+    }
+
+    #[wasm_bindgen(js_name=getParams)]
+    pub fn params(&self) -> Result<JsValue, JsError> {
+        let ser = serde_wasm_bindgen::Serializer::json_compatible();
+        self.params.serialize(&ser).map_err(|e| e.into())
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

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

@@ -0,0 +1,30 @@
+pub mod data_contract;
+pub mod decode;
+pub mod document;
+pub mod identity;
+mod incompatible_protocol_version_error;
+mod invalid_identifier_error;
+mod invalid_signature_public_key_security_level_error;
+mod invalid_state_transition_signature_error;
+mod json_schema_compilation_error;
+mod json_schema_error;
+mod public_key_is_disabled_error;
+mod public_key_security_level_not_met_error;
+pub mod state_transition;
+#[cfg(test)]
+mod test_consensus_error;
+mod unsupported_protocol_version_error;
+mod wrong_public_key_purpose_error;
+
+pub use incompatible_protocol_version_error::*;
+pub use invalid_identifier_error::*;
+pub use invalid_signature_public_key_security_level_error::*;
+pub use invalid_state_transition_signature_error::*;
+pub use json_schema_compilation_error::*;
+pub use json_schema_error::*;
+pub use public_key_is_disabled_error::*;
+pub use public_key_security_level_not_met_error::*;
+#[cfg(test)]
+pub use test_consensus_error::*;
+pub use unsupported_protocol_version_error::*;
+pub use wrong_public_key_purpose_error::*;

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

@@ -0,0 +1,30 @@
+use dpp::identity::KeyID;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=PublicKeyIsDisabledError)]
+pub struct PublicKeyIsDisabledErrorWasm {
+    public_key_id: KeyID,
+    code: u32,
+}
+
+impl PublicKeyIsDisabledErrorWasm {
+    pub fn new(public_key_id: KeyID, code: u32) -> Self {
+        PublicKeyIsDisabledErrorWasm {
+            public_key_id,
+            code,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=PublicKeyIsDisabledError)]
+impl PublicKeyIsDisabledErrorWasm {
+    #[wasm_bindgen(js_name=getPublicKeyId)]
+    pub fn get_public_key_id(&self) -> u64 {
+        self.public_key_id
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

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

@@ -0,0 +1,41 @@
+use dpp::identity::SecurityLevel;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=PublicKeySecurityLevelNotMetError)]
+pub struct PublicKeySecurityLevelNotMetErrorWasm {
+    public_key_security_level: SecurityLevel,
+    required_security_level: SecurityLevel,
+    code: u32,
+}
+
+impl PublicKeySecurityLevelNotMetErrorWasm {
+    pub fn new(
+        public_key_security_level: SecurityLevel,
+        required_security_level: SecurityLevel,
+        code: u32,
+    ) -> Self {
+        PublicKeySecurityLevelNotMetErrorWasm {
+            public_key_security_level,
+            required_security_level,
+            code,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=PublicKeySecurityLevelNotMetError)]
+impl PublicKeySecurityLevelNotMetErrorWasm {
+    #[wasm_bindgen(js_name=getPublicKeySecurityLevel)]
+    pub fn get_public_key_security_level(&self) -> u8 {
+        self.public_key_security_level as u8
+    }
+
+    #[wasm_bindgen(js_name=getRequiredSecurityLevel)]
+    pub fn get_required_security_level(&self) -> u8 {
+        self.required_security_level as u8
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

package/src/errors/consensus/basic/state_transition/invalid_state_transition_type_error.rs

@@ -0,0 +1,29 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=InvalidStateTransitionTypeError)]
+pub struct InvalidStateTransitionTypeErrorWasm {
+    transition_type: u8,
+    code: u32,
+}
+
+impl InvalidStateTransitionTypeErrorWasm {
+    pub fn new(transition_type: u8, code: u32) -> Self {
+        InvalidStateTransitionTypeErrorWasm {
+            transition_type,
+            code,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=InvalidStateTransitionTypeError)]
+impl InvalidStateTransitionTypeErrorWasm {
+    #[wasm_bindgen(js_name=getTransitionType)]
+    pub fn get_transition_type(&self) -> u8 {
+        self.transition_type
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

package/src/errors/consensus/basic/state_transition/missing_state_transition_type_error.rs

@@ -0,0 +1,20 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=MissingStateTransitionTypeError)]
+pub struct MissingStateTransitionTypeErrorWasm {
+    code: u32,
+}
+
+impl MissingStateTransitionTypeErrorWasm {
+    pub fn new(code: u32) -> Self {
+        MissingStateTransitionTypeErrorWasm { code }
+    }
+}
+
+#[wasm_bindgen(js_class=MissingStateTransitionTypeError)]
+impl MissingStateTransitionTypeErrorWasm {
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

package/src/errors/consensus/basic/state_transition/mod.rs

@@ -0,0 +1,7 @@
+mod invalid_state_transition_type_error;
+mod missing_state_transition_type_error;
+mod state_transition_max_size_exceeded_error;
+
+pub use invalid_state_transition_type_error::*;
+pub use missing_state_transition_type_error::*;
+pub use state_transition_max_size_exceeded_error::*;

package/src/errors/consensus/basic/state_transition/state_transition_max_size_exceeded_error.rs

@@ -0,0 +1,36 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=StateTransitionMaxSizeExceededError)]
+pub struct StateTransitionMaxSizeExceededErrorWasm {
+    actual_size_kbytes: usize,
+    max_size_kbytes: usize,
+    code: u32,
+}
+
+impl StateTransitionMaxSizeExceededErrorWasm {
+    pub fn new(actual_size_kbytes: usize, max_size_kbytes: usize, code: u32) -> Self {
+        StateTransitionMaxSizeExceededErrorWasm {
+            actual_size_kbytes,
+            max_size_kbytes,
+            code,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=StateTransitionMaxSizeExceededError)]
+impl StateTransitionMaxSizeExceededErrorWasm {
+    #[wasm_bindgen(js_name=getActualSizeKBytes)]
+    pub fn get_actual_size_kbytes(&self) -> usize {
+        self.actual_size_kbytes
+    }
+
+    #[wasm_bindgen(js_name=getMaxSizeKBytes)]
+    pub fn get_max_size_kbytes(&self) -> usize {
+        self.max_size_kbytes
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

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

@@ -0,0 +1,21 @@
+// use dpp::consensus::{basic::TestConsensusError, ConsensusError};
+// use wasm_bindgen::prelude::*;
+
+// #[wasm_bindgen(js_name=TestConsensusError)]
+// pub struct TestConsensusErrorWasm {
+//     inner: TestConsensusError,
+// }
+
+// impl From<&TestConsensusError> for TestConsensusErrorWasm {
+//     fn from(e: &TestConsensusError) -> Self {
+//         Self { inner: e.clone() }
+//     }
+// }
+
+// #[wasm_bindgen(js_class=TestConsensusError)]
+// impl TestConsensusErrorWasm {
+//     #[wasm_bindgen(js_name=getMessage)]
+//     pub fn get_message(&self) -> String {
+//         self.inner.message.clone()
+//     }
+// }

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

@@ -0,0 +1,32 @@
+use dpp::consensus::basic::UnsupportedProtocolVersionError;
+use dpp::consensus::ConsensusError;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=UnsupportedProtocolVersionError)]
+pub struct UnsupportedProtocolVersionErrorWasm {
+    inner: UnsupportedProtocolVersionError,
+}
+
+impl From<&UnsupportedProtocolVersionError> for UnsupportedProtocolVersionErrorWasm {
+    fn from(e: &UnsupportedProtocolVersionError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+
+#[wasm_bindgen(js_class=UnsupportedProtocolVersionError)]
+impl UnsupportedProtocolVersionErrorWasm {
+    #[wasm_bindgen(js_name=getParsedProtocolVersion)]
+    pub fn parsed_protocol_version(&self) -> u32 {
+        self.inner.parsed_protocol_version()
+    }
+
+    #[wasm_bindgen(js_name=getLatestVersion)]
+    pub fn latest_version(&self) -> u32 {
+        self.inner.latest_version()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        ConsensusError::from(self.inner.clone()).code()
+    }
+}

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

@@ -0,0 +1,37 @@
+use dpp::identity::Purpose;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=WrongPublicKeyPurposeError)]
+pub struct WrongPublicKeyPurposeErrorWasm {
+    public_key_purpose: Purpose,
+    key_purpose_requirement: Purpose,
+    code: u32,
+}
+
+impl WrongPublicKeyPurposeErrorWasm {
+    pub fn new(public_key_purpose: Purpose, key_purpose_requirement: Purpose, code: u32) -> Self {
+        WrongPublicKeyPurposeErrorWasm {
+            public_key_purpose,
+            key_purpose_requirement,
+            code,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=WrongPublicKeyPurposeError)]
+impl WrongPublicKeyPurposeErrorWasm {
+    #[wasm_bindgen(js_name=getPublicKeyPurpose)]
+    pub fn get_public_key_purpose(&self) -> u8 {
+        self.public_key_purpose as u8
+    }
+
+    #[wasm_bindgen(js_name=getKeyPurposeRequirement)]
+    pub fn get_key_purpose_requirement(&self) -> u8 {
+        self.key_purpose_requirement as u8
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

package/src/errors/consensus/fee/balance_is_not_enough_error.rs

@@ -0,0 +1,32 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=BalanceIsNotEnoughError)]
+pub struct BalanceIsNotEnoughErrorWasm {
+    balance: u64,
+    fee: i64,
+    code: u32,
+}
+
+impl BalanceIsNotEnoughErrorWasm {
+    pub fn new(balance: u64, fee: i64, code: u32) -> Self {
+        BalanceIsNotEnoughErrorWasm { balance, fee, code }
+    }
+}
+
+#[wasm_bindgen(js_class=BalanceIsNotEnoughError)]
+impl BalanceIsNotEnoughErrorWasm {
+    #[wasm_bindgen(js_name=getBalance)]
+    pub fn get_balance(&self) -> u64 {
+        self.balance
+    }
+
+    #[wasm_bindgen(js_name=getFee)]
+    pub fn get_fee(&self) -> i64 {
+        self.fee
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

package/src/errors/consensus/fee/mod.rs

@@ -0,0 +1,3 @@
+mod balance_is_not_enough_error;
+
+pub use balance_is_not_enough_error::*;

package/src/errors/consensus/mod.rs

@@ -0,0 +1,4 @@
+pub mod basic;
+pub mod fee;
+pub mod signature;
+pub mod state;

package/src/errors/consensus/signature/identity_not_found_error.rs

@@ -0,0 +1,29 @@
+use dpp::prelude::Identifier;
+use wasm_bindgen::prelude::*;
+
+use crate::buffer::Buffer;
+
+#[wasm_bindgen(js_name=IdentityNotFoundError)]
+pub struct IdentityNotFoundErrorWasm {
+    identity_id: Identifier,
+    code: u32,
+}
+
+impl IdentityNotFoundErrorWasm {
+    pub fn new(identity_id: Identifier, code: u32) -> Self {
+        IdentityNotFoundErrorWasm { identity_id, code }
+    }
+}
+
+#[wasm_bindgen(js_class=IdentityNotFoundError)]
+impl IdentityNotFoundErrorWasm {
+    #[wasm_bindgen(js_name=getIdentityId)]
+    pub fn get_identity_id(&self) -> Buffer {
+        Buffer::from_bytes(self.identity_id.as_bytes())
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

package/src/errors/consensus/signature/mod.rs

@@ -0,0 +1,3 @@
+mod identity_not_found_error;
+
+pub use identity_not_found_error::*;

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

@@ -0,0 +1,31 @@
+use crate::buffer::Buffer;
+use dpp::identifier::Identifier;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=DataContractAlreadyPresentError)]
+pub struct DataContractAlreadyPresentErrorWasm {
+    data_contract_id: Identifier,
+    code: u32,
+}
+
+#[wasm_bindgen(js_class=DataContractAlreadyPresentError)]
+impl DataContractAlreadyPresentErrorWasm {
+    #[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=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}
+
+impl DataContractAlreadyPresentErrorWasm {
+    pub fn new(data_contract_id: Identifier, code: u32) -> Self {
+        Self {
+            data_contract_id,
+            code,
+        }
+    }
+}