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

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

@@ -0,0 +1,60 @@
+use dpp::consensus::basic::identity::InvalidIdentityAssetLockTransactionError;
+
+use dpp::consensus::ConsensusError;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen]
+#[derive(Debug, Default, Clone)]
+pub struct TransactionDecodeError {
+    message: Option<String>,
+}
+
+impl TransactionDecodeError {
+    pub fn get_message(&self) -> &Option<String> {
+        &self.message
+    }
+}
+
+#[wasm_bindgen(js_name=InvalidIdentityAssetLockTransactionError)]
+pub struct InvalidIdentityAssetLockTransactionErrorWasm {
+    validation_error: TransactionDecodeError,
+    message: String,
+}
+
+// TODO: since the validation error can not be cloned,
+//  this error is only partially implemented
+impl From<&InvalidIdentityAssetLockTransactionError>
+    for InvalidIdentityAssetLockTransactionErrorWasm
+{
+    fn from(e: &InvalidIdentityAssetLockTransactionError) -> Self {
+        Self {
+            validation_error: TransactionDecodeError {
+                message: e.validation_error().map(|e| e.to_string()),
+            },
+            message: e.to_string(),
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=InvalidIdentityAssetLockTransactionError)]
+impl InvalidIdentityAssetLockTransactionErrorWasm {
+    #[wasm_bindgen(js_name=getValidationError)]
+    pub fn validation_error(&self) -> JsValue {
+        let kek = self.validation_error.clone();
+        kek.into()
+    }
+
+    #[wasm_bindgen(js_name=getMessage)]
+    pub fn get_message(&self) -> String {
+        self.message.clone()
+    }
+
+    // TODO: finish implementing getCode
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        ConsensusError::InvalidIdentityAssetLockTransactionError(
+            InvalidIdentityAssetLockTransactionError::new(""),
+        )
+        .code()
+    }
+}

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

@@ -0,0 +1,29 @@
+use dpp::consensus::basic::identity::InvalidIdentityAssetLockTransactionOutputError;
+use dpp::consensus::ConsensusError;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=InvalidIdentityAssetLockTransactionOutputError)]
+pub struct InvalidIdentityAssetLockTransactionOutputErrorWasm {
+    inner: InvalidIdentityAssetLockTransactionOutputError,
+}
+
+impl From<&InvalidIdentityAssetLockTransactionOutputError>
+    for InvalidIdentityAssetLockTransactionOutputErrorWasm
+{
+    fn from(e: &InvalidIdentityAssetLockTransactionOutputError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+
+#[wasm_bindgen(js_class=InvalidIdentityAssetLockTransactionOutputError)]
+impl InvalidIdentityAssetLockTransactionOutputErrorWasm {
+    #[wasm_bindgen(js_name=getOutputIndex)]
+    pub fn output_index(&self) -> usize {
+        self.inner.output_index()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        ConsensusError::from(self.inner.clone()).code()
+    }
+}

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

@@ -0,0 +1,29 @@
+use dpp::consensus::basic::identity::InvalidIdentityCreditWithdrawalTransitionCoreFeeError;
+use dpp::consensus::ConsensusError;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=InvalidIdentityCreditWithdrawalTransitionCoreFeeError)]
+pub struct InvalidIdentityCreditWithdrawalTransitionCoreFeeErrorWasm {
+    inner: InvalidIdentityCreditWithdrawalTransitionCoreFeeError,
+}
+
+impl From<&InvalidIdentityCreditWithdrawalTransitionCoreFeeError>
+    for InvalidIdentityCreditWithdrawalTransitionCoreFeeErrorWasm
+{
+    fn from(e: &InvalidIdentityCreditWithdrawalTransitionCoreFeeError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+
+#[wasm_bindgen(js_class=InvalidIdentityCreditWithdrawalTransitionCoreFeeError)]
+impl InvalidIdentityCreditWithdrawalTransitionCoreFeeErrorWasm {
+    #[wasm_bindgen(js_name=getCoreFee)]
+    pub fn core_fee(&self) -> u32 {
+        self.inner.core_fee()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        ConsensusError::from(self.inner.clone()).code()
+    }
+}

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

@@ -0,0 +1,32 @@
+use dpp::consensus::basic::identity::InvalidIdentityCreditWithdrawalTransitionOutputScriptError;
+use dpp::consensus::ConsensusError;
+use wasm_bindgen::prelude::*;
+
+use crate::buffer::Buffer;
+
+#[wasm_bindgen(js_name=InvalidIdentityCreditWithdrawalTransitionOutputScriptError)]
+pub struct InvalidIdentityCreditWithdrawalTransitionOutputScriptErrorWasm {
+    inner: InvalidIdentityCreditWithdrawalTransitionOutputScriptError,
+}
+
+impl From<&InvalidIdentityCreditWithdrawalTransitionOutputScriptError>
+    for InvalidIdentityCreditWithdrawalTransitionOutputScriptErrorWasm
+{
+    fn from(e: &InvalidIdentityCreditWithdrawalTransitionOutputScriptError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+
+#[wasm_bindgen(js_class=InvalidIdentityCreditWithdrawalTransitionOutputScriptError)]
+impl InvalidIdentityCreditWithdrawalTransitionOutputScriptErrorWasm {
+    #[wasm_bindgen(js_name=getOutputScript)]
+    pub fn output_script(&self) -> Buffer {
+        let script = self.inner.output_script();
+        Buffer::from_bytes(script.to_bytes().as_ref())
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn code(&self) -> u32 {
+        ConsensusError::from(self.inner.clone()).code()
+    }
+}

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

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

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

@@ -0,0 +1,39 @@
+use crate::errors::PublicKeyValidationErrorWasm;
+use dpp::codes::ErrorWithCode;
+use dpp::consensus::basic::identity::InvalidIdentityPublicKeyDataError;
+
+use dpp::errors::consensus::ConsensusError as DPPConsensusError;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=InvalidIdentityPublicKeyDataError)]
+pub struct InvalidIdentityPublicKeyDataErrorWasm {
+    inner: InvalidIdentityPublicKeyDataError,
+}
+
+impl From<&InvalidIdentityPublicKeyDataError> for InvalidIdentityPublicKeyDataErrorWasm {
+    fn from(e: &InvalidIdentityPublicKeyDataError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+
+#[wasm_bindgen(js_class=InvalidIdentityPublicKeyDataError)]
+impl InvalidIdentityPublicKeyDataErrorWasm {
+    #[wasm_bindgen(js_name=getPublicKeyId)]
+    pub fn public_key_id(&self) -> u32 {
+        // TODO: think about what to do with that conversion
+        self.inner.public_key_id() as u32
+    }
+
+    #[wasm_bindgen(js_name=getValidationError)]
+    pub fn validation_error(&self) -> Option<PublicKeyValidationErrorWasm> {
+        self.inner
+            .validation_error()
+            .as_ref()
+            .map(|err| PublicKeyValidationErrorWasm::from(err.clone()))
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn code(&self) -> u32 {
+        DPPConsensusError::from(self.inner.clone()).get_code()
+    }
+}

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

@@ -0,0 +1,42 @@
+use dpp::codes::ErrorWithCode;
+use dpp::consensus::basic::identity::InvalidIdentityPublicKeySecurityLevelError;
+
+use dpp::errors::consensus::ConsensusError as DPPConsensusError;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=InvalidIdentityPublicKeySecurityLevelError)]
+pub struct InvalidIdentityPublicKeySecurityLevelErrorWasm {
+    inner: InvalidIdentityPublicKeySecurityLevelError,
+}
+
+impl From<&InvalidIdentityPublicKeySecurityLevelError>
+    for InvalidIdentityPublicKeySecurityLevelErrorWasm
+{
+    fn from(e: &InvalidIdentityPublicKeySecurityLevelError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+
+#[wasm_bindgen(js_class=InvalidIdentityPublicKeySecurityLevelError)]
+impl InvalidIdentityPublicKeySecurityLevelErrorWasm {
+    #[wasm_bindgen(js_name=getPublicKeyId)]
+    pub fn public_key_id(&self) -> u32 {
+        // TODO: think about what to do with that conversion
+        self.inner.public_key_id() as u32
+    }
+
+    #[wasm_bindgen(js_name=getPurpose)]
+    pub fn purpose(&self) -> u8 {
+        self.inner.purpose() as u8
+    }
+
+    #[wasm_bindgen(js_name=getSecurityLevel)]
+    pub fn security_level(&self) -> u8 {
+        self.inner.security_level() as u8
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn code(&self) -> u32 {
+        DPPConsensusError::from(self.inner.clone()).get_code()
+    }
+}

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

@@ -0,0 +1,30 @@
+use dpp::identity::KeyType;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=InvalidIdentityPublicKeyTypeError)]
+pub struct InvalidIdentityPublicKeyTypeErrorWasm {
+    public_key_type: KeyType,
+    code: u32,
+}
+
+impl InvalidIdentityPublicKeyTypeErrorWasm {
+    pub fn new(public_key_type: KeyType, code: u32) -> Self {
+        InvalidIdentityPublicKeyTypeErrorWasm {
+            public_key_type,
+            code,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=InvalidIdentityPublicKeyTypeError)]
+impl InvalidIdentityPublicKeyTypeErrorWasm {
+    #[wasm_bindgen(js_name=getPublicKeyType)]
+    pub fn get_public_key_type(&self) -> u8 {
+        self.public_key_type as u8
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

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

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

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

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

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

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

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

@@ -0,0 +1,29 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=MissingPublicKeyError)]
+pub struct MissingPublicKeyErrorWasm {
+    public_key_id: u64,
+    code: u32,
+}
+
+impl MissingPublicKeyErrorWasm {
+    pub fn new(public_key_id: u64, code: u32) -> Self {
+        MissingPublicKeyErrorWasm {
+            public_key_id,
+            code,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=MissingPublicKeyError)]
+impl MissingPublicKeyErrorWasm {
+    #[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/identity/mod.rs

@@ -0,0 +1,45 @@
+mod duplicated_identity_public_key_error;
+mod duplicated_identity_public_key_id_error;
+mod identity_asset_lock_proof_locked_transaction_mismatch_error;
+mod identity_asset_lock_transaction_is_not_found_error;
+mod identity_asset_lock_transaction_out_point_already_exists_error;
+mod identity_asset_lock_transaction_output_not_found_error;
+mod identity_insufficient_balance_error;
+mod invalid_asset_lock_proof_core_chain_height_error;
+mod invalid_asset_lock_proof_transaction_height_error;
+mod invalid_asset_lock_transaction_output_return_size_error;
+mod invalid_identity_asset_lock_transaction_error;
+mod invalid_identity_asset_lock_transaction_output_error;
+mod invalid_identity_credit_withdrawal_transition_core_fee_error;
+mod invalid_identity_credit_withdrawal_transition_output_script_error;
+pub mod invalid_identity_key_signature_error;
+mod invalid_identity_public_key_data_error;
+mod invalid_identity_public_key_security_level_error;
+mod invalid_identity_public_key_type_error;
+mod invalid_instant_asset_lock_proof_error;
+mod invalid_instant_asset_lock_proof_signature_error;
+mod missing_master_public_key_error;
+mod missing_public_key_error;
+
+pub use duplicated_identity_public_key_error::*;
+pub use duplicated_identity_public_key_id_error::*;
+pub use identity_asset_lock_proof_locked_transaction_mismatch_error::*;
+pub use identity_asset_lock_transaction_is_not_found_error::*;
+pub use identity_asset_lock_transaction_out_point_already_exists_error::*;
+pub use identity_asset_lock_transaction_output_not_found_error::*;
+pub use identity_insufficient_balance_error::*;
+pub use invalid_asset_lock_proof_core_chain_height_error::*;
+pub use invalid_asset_lock_proof_transaction_height_error::*;
+pub use invalid_asset_lock_transaction_output_return_size_error::*;
+pub use invalid_identity_asset_lock_transaction_error::*;
+pub use invalid_identity_asset_lock_transaction_output_error::*;
+pub use invalid_identity_credit_withdrawal_transition_core_fee_error::*;
+pub use invalid_identity_credit_withdrawal_transition_output_script_error::*;
+pub use invalid_identity_key_signature_error::*;
+pub use invalid_identity_public_key_data_error::*;
+pub use invalid_identity_public_key_security_level_error::*;
+pub use invalid_identity_public_key_type_error::*;
+pub use invalid_instant_asset_lock_proof_error::*;
+pub use invalid_instant_asset_lock_proof_signature_error::*;
+pub use missing_master_public_key_error::*;
+pub use missing_public_key_error::*;

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

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

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

@@ -0,0 +1,36 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=InvalidIdentifierError)]
+pub struct InvalidIdentifierErrorWasm {
+    identifier_name: String,
+    error: String,
+    code: u32,
+}
+
+impl InvalidIdentifierErrorWasm {
+    pub fn new(identifier_name: String, error: String, code: u32) -> Self {
+        InvalidIdentifierErrorWasm {
+            identifier_name,
+            error,
+            code,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=InvalidIdentifierError)]
+impl InvalidIdentifierErrorWasm {
+    #[wasm_bindgen(js_name=getIdentifierName)]
+    pub fn get_identifier_name(&self) -> String {
+        self.identifier_name.clone()
+    }
+
+    #[wasm_bindgen(js_name=getError)]
+    pub fn get_error(&self) -> String {
+        self.error.clone()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

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

@@ -0,0 +1,41 @@
+use dpp::identity::SecurityLevel;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=InvalidSignaturePublicKeySecurityLevelError)]
+pub struct InvalidSignaturePublicKeySecurityLevelErrorWasm {
+    public_key_security_level: SecurityLevel,
+    required_key_security_level: SecurityLevel,
+    code: u32,
+}
+
+impl InvalidSignaturePublicKeySecurityLevelErrorWasm {
+    pub fn new(
+        public_key_security_level: SecurityLevel,
+        required_key_security_level: SecurityLevel,
+        code: u32,
+    ) -> Self {
+        InvalidSignaturePublicKeySecurityLevelErrorWasm {
+            public_key_security_level,
+            required_key_security_level,
+            code,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class=InvalidSignaturePublicKeySecurityLevelError)]
+impl InvalidSignaturePublicKeySecurityLevelErrorWasm {
+    #[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=getRequiredKeySecurityLevel)]
+    pub fn get_required_key_security_level(&self) -> u8 {
+        self.required_key_security_level as u8
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}

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

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

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

@@ -0,0 +1,26 @@
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=JsonSchemaCompilationError)]
+pub struct JsonSchemaCompilationErrorWasm {
+    error: String,
+    code: u32,
+}
+
+impl JsonSchemaCompilationErrorWasm {
+    pub fn new(error: String, code: u32) -> Self {
+        JsonSchemaCompilationErrorWasm { error, code }
+    }
+}
+
+#[wasm_bindgen(js_class=JsonSchemaCompilationError)]
+impl JsonSchemaCompilationErrorWasm {
+    #[wasm_bindgen(js_name=getError)]
+    pub fn get_error(&self) -> String {
+        self.error.clone()
+    }
+
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        self.code
+    }
+}