@dashevo/wasm-dpp 0.24.0-dev.12 → 0.24.0-dev.13

package/src/document/state_transition/document_batch_transition/document_transition/mod.rs

@@ -1,14 +1,134 @@
 mod document_create_transition;
 mod document_delete_transition;
-mod document_update_transition;
+mod document_replace_transition;
 
 pub use document_create_transition::*;
 pub use document_delete_transition::*;
-pub use document_update_transition::*;
+pub use document_replace_transition::*;
 
-use dpp::prelude::DocumentTransition;
+use dpp::{
+    document::document_transition::{DocumentTransitionExt, DocumentTransitionObjectLike},
+    prelude::{DocumentTransition, Identifier},
+    util::json_schema::JsonSchemaExt,
+};
+use serde::Serialize;
 use wasm_bindgen::prelude::*;
 
+use crate::{
+    buffer::Buffer, identifier::IdentifierWrapper, utils::WithJsError, with_js_error, BinaryType,
+    DataContractWasm,
+};
+
+#[wasm_bindgen]
+#[derive(Debug, Clone)]
+pub struct DocumentTransitionWasm(DocumentTransition);
+
+#[wasm_bindgen(js_class=DocumentTransitionWasm)]
+impl DocumentTransitionWasm {
+    #[wasm_bindgen(js_name=getId)]
+    pub fn get_id(&self) -> IdentifierWrapper {
+        self.0.get_id().to_owned().into()
+    }
+
+    #[wasm_bindgen(js_name=getType)]
+    pub fn get_type(&self) -> String {
+        self.0.get_document_type().to_owned()
+    }
+
+    #[wasm_bindgen(js_name=getAction)]
+    pub fn get_action(&self) -> u8 {
+        self.0.get_action().into()
+    }
+
+    #[wasm_bindgen(js_name=getDataContract)]
+    pub fn get_data_contract(&self) -> DataContractWasm {
+        self.0.get_data_contract().to_owned().into()
+    }
+
+    #[wasm_bindgen(js_name=getDataContractId)]
+    pub fn get_data_contract_id(&self) -> IdentifierWrapper {
+        self.0.get_data_contract_id().to_owned().into()
+    }
+
+    #[wasm_bindgen(js_name=get)]
+    pub fn get(&self, path: &str) -> JsValue {
+        let binary_type = self.get_binary_type_of_path(path);
+
+        if let Some(value) = self.0.get_dynamic_property(path) {
+            match binary_type {
+                BinaryType::Identifier => {
+                    if let Ok(bytes) = serde_json::from_value::<Vec<u8>>(value.to_owned()) {
+                        let id: IdentifierWrapper = Identifier::from_bytes(&bytes).unwrap().into();
+
+                        return id.into();
+                    }
+                }
+                BinaryType::Buffer => {
+                    if let Ok(bytes) = serde_json::from_value::<Vec<u8>>(value.to_owned()) {
+                        return Buffer::from_bytes(&bytes).into();
+                    }
+                }
+                BinaryType::None => {
+                    let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+                    if let Ok(js_value) = value.serialize(&serializer) {
+                        return js_value;
+                    }
+                }
+            }
+        }
+
+        JsValue::undefined()
+    }
+
+    #[wasm_bindgen(js_name=getObject)]
+    pub fn to_object(&self, _options: &JsValue) -> Result<JsValue, JsValue> {
+        // TODO options??
+
+        match self.0 {
+            DocumentTransition::Create(ref t) => {
+                DocumentCreateTransitionWasm::from(t.to_owned()).to_object()
+            }
+            DocumentTransition::Replace(ref t) => {
+                DocumentReplaceTransitionWasm::from(t.to_owned()).to_object()
+            }
+            DocumentTransition::Delete(ref t) => {
+                DocumentDeleteTransitionWasm::from(t.to_owned()).to_object()
+            }
+        }
+    }
+
+    #[wasm_bindgen(js_name=toJSON)]
+    pub fn to_json(&self) -> Result<JsValue, JsValue> {
+        let json_value = self.0.to_json().with_js_error()?;
+        with_js_error!(json_value.serialize(&serde_wasm_bindgen::Serializer::json_compatible()))
+    }
+}
+
+impl DocumentTransitionWasm {
+    fn get_binary_type_of_path(&self, path: impl AsRef<str>) -> BinaryType {
+        let maybe_binary_properties = self
+            .0
+            .get_data_contract()
+            .get_binary_properties(self.0.get_document_type());
+
+        if let Ok(binary_properties) = maybe_binary_properties {
+            if let Some(data) = binary_properties.get(path.as_ref()) {
+                if data.is_type_of_identifier() {
+                    return BinaryType::Identifier;
+                }
+                return BinaryType::Buffer;
+            }
+        }
+        BinaryType::None
+    }
+}
+
+impl From<DocumentTransition> for DocumentTransitionWasm {
+    fn from(v: DocumentTransition) -> Self {
+        DocumentTransitionWasm(v)
+    }
+}
+
 pub fn from_document_transition_to_js_value(document_transition: DocumentTransition) -> JsValue {
     match document_transition {
         DocumentTransition::Create(create_transition) => {

package/src/document/state_transition/document_batch_transition/mod.rs

@@ -1 +1,379 @@
+use dpp::{
+    document::{
+        state_transition::documents_batch_transition::property_names, DocumentsBatchTransition,
+    },
+    prelude::{DataContract, Document, Identifier},
+    state_transition::{
+        state_transition_execution_context::StateTransitionExecutionContext,
+        StateTransitionConvert, StateTransitionIdentitySigned, StateTransitionLike,
+        StateTransitionType,
+    },
+    util::json_value::JsonValueExt,
+};
+use js_sys::{Array, Reflect};
+use serde::Serialize;
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    bls_adapter::{BlsAdapter, JsBlsAdapter},
+    buffer::Buffer,
+    document_batch_transition::document_transition::DocumentTransitionWasm,
+    identifier::IdentifierWrapper,
+    lodash::lodash_set,
+    utils::{ToSerdeJSONExt, WithJsError},
+    DocumentWasm, IdentityPublicKeyWasm,
+};
 pub mod document_transition;
+
+#[derive(Debug)]
+#[wasm_bindgen(js_name = DocumentsBatchTransition)]
+pub struct DocumentsBatchTransitionWASM(DocumentsBatchTransition);
+
+/// Collections of Documents split by actions
+#[derive(Debug, Default)]
+#[wasm_bindgen(js_name=DocumentsContainer)]
+pub struct DocumentsContainer {
+    create: Vec<Document>,
+    replace: Vec<Document>,
+    delete: Vec<Document>,
+}
+
+#[wasm_bindgen(js_class=DocumentsContainer)]
+impl DocumentsContainer {
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    #[wasm_bindgen(js_name=pushDocumentCreate)]
+    pub fn push_document_create(&mut self, d: DocumentWasm) {
+        self.create.push(d.0);
+    }
+
+    #[wasm_bindgen(js_name=pushDocumentReplace)]
+    pub fn push_document_replace(&mut self, d: DocumentWasm) {
+        self.replace.push(d.0);
+    }
+
+    #[wasm_bindgen(js_name=pushDocumentDelete)]
+    pub fn push_document_delete(&mut self, d: DocumentWasm) {
+        self.delete.push(d.0);
+    }
+}
+
+impl DocumentsContainer {
+    pub fn take_documents_create(&mut self) -> Vec<Document> {
+        std::mem::take(&mut self.create)
+    }
+
+    pub fn take_documents_replace(&mut self) -> Vec<Document> {
+        std::mem::take(&mut self.replace)
+    }
+
+    pub fn take_documents_delete(&mut self) -> Vec<Document> {
+        std::mem::take(&mut self.delete)
+    }
+}
+
+#[wasm_bindgen(js_class=DocumentsBatchTransition)]
+impl DocumentsBatchTransitionWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn from_raw_object(
+        js_raw_transition: JsValue,
+        data_contracts: Array,
+    ) -> Result<DocumentsBatchTransitionWASM, JsValue> {
+        let data_contracts_array_js = Array::from(&data_contracts);
+
+        let mut data_contracts: Vec<DataContract> = vec![];
+        for contract in data_contracts_array_js.iter() {
+            let json_value = contract.with_serde_to_json_value()?;
+            let data_contract = DataContract::from_json_object(json_value).with_js_error()?;
+            data_contracts.push(data_contract);
+        }
+
+        let documents_batch_transition = DocumentsBatchTransition::from_json_object(
+            js_raw_transition.with_serde_to_json_value()?,
+            data_contracts,
+        )
+        .with_js_error()?;
+
+        Ok(documents_batch_transition.into())
+    }
+
+    #[wasm_bindgen(js_name=getType)]
+    pub fn get_type(&self) -> u8 {
+        StateTransitionType::DocumentsBatch.into()
+    }
+
+    #[wasm_bindgen(js_name=getOwnerId)]
+    pub fn get_owner_id(&self) -> IdentifierWrapper {
+        self.0.get_owner_id().to_owned().into()
+    }
+
+    #[wasm_bindgen(js_name=getTransitions)]
+    pub fn get_transitions(&self) -> js_sys::Array {
+        let array = js_sys::Array::new();
+        let transitions = self.0.get_transitions();
+
+        for tr in transitions.iter().cloned() {
+            let transition: DocumentTransitionWasm = tr.into();
+            array.push(&transition.into());
+        }
+
+        array
+    }
+
+    #[wasm_bindgen(js_name=toJSON)]
+    pub fn to_json(&self) -> Result<JsValue, JsValue> {
+        let value = self.0.to_json(false).with_js_error()?;
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+
+        let is_null_signature = value.get(property_names::SIGNATURE).is_none();
+        let is_null_signature_public_key_id =
+            value.get(property_names::SIGNATURE_PUBLIC_KEY_ID).is_none();
+
+        let js_value = value.serialize(&serializer)?;
+
+        if is_null_signature {
+            js_sys::Reflect::set(
+                &js_value,
+                &property_names::SIGNATURE.into(),
+                &JsValue::undefined(),
+            )?;
+        }
+        if is_null_signature_public_key_id {
+            js_sys::Reflect::set(
+                &js_value,
+                &property_names::SIGNATURE_PUBLIC_KEY_ID.into(),
+                &JsValue::undefined(),
+            )?;
+        }
+
+        Ok(js_value)
+    }
+
+    #[wasm_bindgen(js_name=toObject)]
+    pub fn to_object(&self, options: &JsValue) -> Result<JsValue, JsValue> {
+        let skip_signature = if options.is_object() {
+            let options = options.with_serde_to_json_value()?;
+            options.get_bool("skipSignature").unwrap_or_default()
+        } else {
+            false
+        };
+
+        let mut value = self.0.to_object(skip_signature).with_js_error()?;
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+        let js_value = value.serialize(&serializer)?;
+
+        // Transform every transition individually
+        let transitions = Array::new();
+        for transition in self.0.transitions.iter() {
+            let js_value =
+                DocumentTransitionWasm::from(transition.to_owned()).to_object(options)?;
+            transitions.push(&js_value);
+        }
+        // Replace the whole collection of transitions
+        Reflect::set(
+            &js_value,
+            &property_names::TRANSITIONS.into(),
+            &transitions.into(),
+        )?;
+
+        // Transform paths that are specific to the DocumentsBatchTransition
+        for path in DocumentsBatchTransition::binary_property_paths() {
+            if let Ok(bytes) = value.remove_path_into::<Vec<u8>>(path) {
+                let buffer = Buffer::from_bytes(&bytes);
+                lodash_set(&js_value, path, buffer.into());
+            }
+        }
+        for path in DocumentsBatchTransition::identifiers_property_paths() {
+            if let Ok(bytes) = value.remove_path_into::<Vec<u8>>(path) {
+                let id = IdentifierWrapper::new(bytes)?;
+                lodash_set(&js_value, path, id.into());
+            }
+        }
+
+        if value.get(property_names::SIGNATURE).is_none() && !skip_signature {
+            js_sys::Reflect::set(
+                &js_value,
+                &property_names::SIGNATURE.into(),
+                &JsValue::undefined(),
+            )?;
+        }
+        if value.get(property_names::SIGNATURE_PUBLIC_KEY_ID).is_none() {
+            js_sys::Reflect::set(
+                &js_value,
+                &property_names::SIGNATURE_PUBLIC_KEY_ID.into(),
+                &JsValue::undefined(),
+            )?;
+        }
+
+        Ok(js_value)
+    }
+
+    #[wasm_bindgen(js_name=getModifiedDataIds)]
+    pub fn get_modified_ids(&self) -> Array {
+        let array = Array::new();
+
+        for id in self.0.get_modified_data_ids() {
+            let id = <IdentifierWrapper as From<Identifier>>::from(id.to_owned());
+            array.push(&id.into());
+        }
+
+        array
+    }
+
+    // AbstractSTateTransitionIdentitySigned methods
+    #[wasm_bindgen(js_name=getSignaturePublicKeyId)]
+    pub fn get_signature_public_key_id(&self) -> Option<f64> {
+        self.0.get_signature_public_key_id().map(|v| v as f64)
+    }
+
+    #[wasm_bindgen(js_name=sign)]
+    pub fn sign(
+        &mut self,
+        identity_public_key: &IdentityPublicKeyWasm,
+        private_key: &[u8],
+        bls: JsBlsAdapter,
+    ) -> Result<(), JsValue> {
+        self.0
+            .sign(identity_public_key.inner(), private_key, &BlsAdapter(bls))
+            .with_js_error()
+    }
+
+    #[wasm_bindgen(js_name=verifyPublicKeyLevelAndPurpose)]
+    pub fn verify_public_key_level_and_purpose(
+        &self,
+        public_key: &IdentityPublicKeyWasm,
+    ) -> Result<(), JsValue> {
+        self.0
+            .verify_public_key_level_and_purpose(public_key.inner())
+            .with_js_error()
+    }
+
+    #[wasm_bindgen(js_name=verifyPublicKeyIsEnabled)]
+    pub fn verify_public_key_is_enabled(
+        &self,
+        public_key: &IdentityPublicKeyWasm,
+    ) -> Result<(), JsValue> {
+        self.0
+            .verify_public_key_is_enabled(public_key.inner())
+            .with_js_error()
+    }
+
+    #[wasm_bindgen(js_name=verifySignature)]
+    pub fn verify_signature(
+        &self,
+        public_key: &IdentityPublicKeyWasm,
+        bls: JsBlsAdapter,
+    ) -> Result<(), JsValue> {
+        self.0
+            .verify_signature(public_key.inner(), &BlsAdapter(bls))
+            .with_js_error()
+    }
+
+    #[wasm_bindgen(js_name=setSignaturePublicKey)]
+    pub fn set_signature_public_key(&mut self, key_id: u64) {
+        self.0.set_signature_public_key_id(key_id)
+    }
+
+    #[wasm_bindgen(js_name=getSecurityLevelRequirement)]
+    pub fn get_security_level_requirement(&self) -> u8 {
+        self.0.get_security_level_requirement().into()
+    }
+
+    // AbstractStateTransition methods
+    #[wasm_bindgen(js_name=getProtocolVersion)]
+    pub fn get_protocol_version(&self) -> u32 {
+        self.0.get_protocol_version()
+    }
+
+    #[wasm_bindgen(js_name=getSignature)]
+    pub fn get_signature(&self) -> Vec<u8> {
+        self.0.get_signature().to_owned()
+    }
+
+    #[wasm_bindgen(js_name=setSignature)]
+    pub fn set_signature(&mut self, signature: Vec<u8>) {
+        self.0.set_signature(signature)
+    }
+
+    #[wasm_bindgen(js_name=calculateFee)]
+    pub fn calculate_fee(&self) -> i64 {
+        self.0.calculate_fee()
+    }
+
+    #[wasm_bindgen(js_name=isDocumentStateTransition)]
+    pub fn is_document_state_transition(&self) -> bool {
+        self.0.is_document_state_transition()
+    }
+
+    #[wasm_bindgen(js_name=isDataContractStateTransition)]
+    pub fn is_data_contract_state_transition(&self) -> bool {
+        self.0.is_data_contract_state_transition()
+    }
+
+    #[wasm_bindgen(js_name=isIdentityStateTransition)]
+    pub fn is_identity_state_transition(&self) -> bool {
+        self.0.is_identity_state_transition()
+    }
+
+    #[wasm_bindgen(js_name=setExecutionContext)]
+    pub fn set_execution_context(&mut self, context: StateExecutionContext) {
+        self.0.set_execution_context(context.into_inner());
+    }
+
+    #[wasm_bindgen(js_name=getExecutionContext)]
+    pub fn get_execution_context(&mut self) -> StateExecutionContext {
+        StateExecutionContext(self.0.get_execution_context().to_owned())
+    }
+
+    #[wasm_bindgen(js_name=toBuffer)]
+    pub fn to_buffer(&self, options: &JsValue) -> Result<Buffer, JsValue> {
+        let skip_signature = if options.is_object() {
+            let options = options.with_serde_to_json_value()?;
+            options.get_bool("skipSignature").unwrap_or_default()
+        } else {
+            false
+        };
+        let bytes = self.0.to_buffer(skip_signature).with_js_error()?;
+
+        Ok(Buffer::from_bytes(&bytes))
+    }
+
+    #[wasm_bindgen(js_name=hash)]
+    pub fn hash(&self, options: JsValue) -> Result<Buffer, JsValue> {
+        let skip_signature = if options.is_object() {
+            let options = options.with_serde_to_json_value()?;
+            options.get_bool("skipSignature").unwrap_or_default()
+        } else {
+            false
+        };
+        let bytes = self.0.hash(skip_signature).with_js_error()?;
+
+        Ok(Buffer::from_bytes(&bytes))
+    }
+}
+
+#[wasm_bindgen(js_name=StateExecutionContext)]
+pub struct StateExecutionContext(StateTransitionExecutionContext);
+
+impl StateExecutionContext {
+    pub fn into_inner(self) -> StateTransitionExecutionContext {
+        self.0
+    }
+
+    pub fn inner(&self) -> &StateTransitionExecutionContext {
+        &self.0
+    }
+
+    pub fn inner_mut(&mut self) -> &mut StateTransitionExecutionContext {
+        &mut self.0
+    }
+}
+
+impl From<DocumentsBatchTransition> for DocumentsBatchTransitionWASM {
+    fn from(t: DocumentsBatchTransition) -> Self {
+        DocumentsBatchTransitionWASM(t)
+    }
+}

package/src/document/validator.rs

@@ -0,0 +1,30 @@
+use std::sync::Arc;
+
+use dpp::document::document_validator::DocumentValidator;
+
+use wasm_bindgen::prelude::*;
+
+use crate::version::ProtocolVersionValidatorWasm;
+
+#[wasm_bindgen(js_name = DocumentValidator)]
+pub struct DocumentValidatorWasm(DocumentValidator);
+
+#[wasm_bindgen(js_class=DocumentValidator)]
+impl DocumentValidatorWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(protocol_validator: ProtocolVersionValidatorWasm) -> DocumentValidatorWasm {
+        DocumentValidatorWasm(DocumentValidator::new(Arc::new(protocol_validator.into())))
+    }
+}
+
+impl From<DocumentValidator> for DocumentValidatorWasm {
+    fn from(doc_validator: DocumentValidator) -> Self {
+        DocumentValidatorWasm(doc_validator)
+    }
+}
+
+impl From<DocumentValidatorWasm> for DocumentValidator {
+    fn from(val: DocumentValidatorWasm) -> Self {
+        val.0
+    }
+}

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

@@ -1,5 +1,6 @@
 use dpp::consensus::basic::identity::IdentityAssetLockProofLockedTransactionMismatchError;
 use dpp::consensus::ConsensusError;
+use dpp::dashcore::hashes::Hash;
 use wasm_bindgen::prelude::*;
 
 use crate::buffer::Buffer;
@@ -22,13 +23,16 @@ impl IdentityAssetLockProofLockedTransactionMismatchErrorWasm {
     #[wasm_bindgen(js_name=getInstantLockTransactionId)]
     pub fn instant_lock_transaction_id(&self) -> Buffer {
         let tx_id = self.inner.instant_lock_transaction_id();
-        Buffer::from_bytes(tx_id.to_vec().as_ref())
+        Buffer::from_bytes(&tx_id)
     }
 
     #[wasm_bindgen(js_name=getAssetLockTransactionId)]
     pub fn asset_lock_transaction_id(&self) -> Buffer {
         let tx_id = self.inner.asset_lock_transaction_id();
-        Buffer::from_bytes(tx_id.to_vec().as_ref())
+        let mut hash_bytes = tx_id.as_hash().into_inner();
+        hash_bytes.reverse();
+
+        Buffer::from_bytes(&hash_bytes)
     }
 
     #[wasm_bindgen(js_name=getCode)]

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

@@ -1,5 +1,6 @@
 use dpp::consensus::basic::identity::IdentityAssetLockTransactionOutPointAlreadyExistsError;
 use dpp::consensus::ConsensusError;
+use dpp::dashcore::hashes::Hash;
 use wasm_bindgen::prelude::*;
 
 use crate::buffer::Buffer;
@@ -19,7 +20,7 @@ impl From<&IdentityAssetLockTransactionOutPointAlreadyExistsError>
 
 #[wasm_bindgen(js_class=IdentityAssetLockTransactionOutPointAlreadyExistsError)]
 impl IdentityAssetLockTransactionOutPointAlreadyExistsErrorWasm {
-    #[wasm_bindgen(js_name=getDuplicatedIds)]
+    #[wasm_bindgen(js_name=getOutputIndex)]
     pub fn output_index(&self) -> usize {
         self.inner.output_index()
     }
@@ -27,7 +28,9 @@ impl IdentityAssetLockTransactionOutPointAlreadyExistsErrorWasm {
     #[wasm_bindgen(js_name=getTransactionId)]
     pub fn transaction_id(&self) -> Buffer {
         let tx_id = self.inner.transaction_id();
-        Buffer::from_bytes(tx_id.to_vec().as_ref())
+        let mut tx_id_bytes = tx_id.as_hash().into_inner();
+        tx_id_bytes.reverse();
+        Buffer::from_bytes(&tx_id_bytes)
     }
 
     #[wasm_bindgen(js_name=getCode)]

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

@@ -22,9 +22,9 @@ impl InvalidAssetLockProofTransactionHeightErrorWasm {
         self.inner.proof_core_chain_locked_height()
     }
 
-    #[wasm_bindgen(js_name=getCurrentCoreChainLockedHeight)]
-    pub fn current_core_chain_locked_height(&self) -> Option<u32> {
-        self.inner.current_core_chain_locked_height()
+    #[wasm_bindgen(js_name=getTransactionHeight)]
+    pub fn transaction_height(&self) -> Option<u32> {
+        self.inner.transaction_height()
     }
 
     #[wasm_bindgen(js_name=getCode)]

package/src/errors/dpp_error.rs

@@ -0,0 +1,17 @@
+use crate::identity::errors::{
+    AssetLockOutputNotFoundErrorWasm, AssetLockTransactionIsNotFoundErrorWasm,
+};
+use dpp::DPPError;
+use wasm_bindgen::JsValue;
+
+pub fn from_dpp_error_ref(e: &DPPError) -> JsValue {
+    match e {
+        DPPError::AssetLockOutputNotFoundError(e) => {
+            AssetLockOutputNotFoundErrorWasm::from(e).into()
+        }
+        DPPError::AssetLockTransactionIsNotFoundError(e) => {
+            AssetLockTransactionIsNotFoundErrorWasm::from(e).into()
+        }
+        _ => unimplemented!(),
+    }
+}

package/src/errors/from.rs

@@ -5,8 +5,13 @@ 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 super::consensus_error::from_consensus_error;
+
 pub fn from_dpp_err(pe: ProtocolError) -> JsValue {
     match pe {
+        ProtocolError::AbstractConsensusError(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),

package/src/errors/js_conversion.rs

@@ -41,23 +41,38 @@ impl From<serde_wasm_bindgen::Error> for RustConversionError {
 #[macro_export]
 macro_rules! with_js_error {
     ($o:expr) => {
-        $o.map_err(|e| RustConversionError::from(e).to_js_value())
+        $o.map_err(|e| $crate::errors::RustConversionError::from(e).to_js_value())
     };
 }
 
 #[macro_export]
 macro_rules! bail_js {
     ($msg:literal) => ({
-        return Err(RustConversionError::from(String::from($msg)).to_js_value())
+        return Err($crate::errors::RustConversionError::from(String::from($msg)).to_js_value())
     });
 
     ($err:expr $(,)?) => ({
         use $crate::private::kind::*;
-        return Err(RustConversionError::from($err).to_js_value())
+        return Err($crate::errors::RustConversionError::from($err).to_js_value())
     });
 
     ($fmt:expr, $($arg:tt)*) => {
-        return Err(RustConversionError::from(format!($fmt, $($arg)*)).to_js_value())
+        return Err($crate::errors::RustConversionError::from(format!($fmt, $($arg)*)).to_js_value())
     };
 
 }
+
+#[macro_export]
+macro_rules! console_log {
+    ($msg:literal) => {{
+        web_sys::console::log_1(&format!($msg).into())
+    }};
+
+    ($msg:expr $(,)?) => {{
+        web_sys::console::log_1(&format!("{}", $msg).into())
+    }};
+
+    ($fmt:expr, $($arg:tt)*) => {
+        web_sys::console::log_1(&format!($fmt, $($arg)*).into())
+    };
+}

package/src/errors/mod.rs

@@ -9,3 +9,5 @@ pub mod protocol_error;
 mod public_key_validation_error;
 
 pub use public_key_validation_error::*;
+
+pub mod dpp_error;