@dashevo/wasm-dpp 0.25.0-dev.8 → 0.25.0

package/src/state_transition/errors/invalid_state_transition_error.rs

@@ -1,5 +1,6 @@
 use dpp::consensus::ConsensusError;
-use wasm_bindgen::{prelude::wasm_bindgen, JsValue};
+use serde::Serialize;
+use wasm_bindgen::{prelude::wasm_bindgen, JsError, JsValue};
 
 use crate::{
     buffer::Buffer, errors::consensus::consensus_error::from_consensus_error_ref,
@@ -45,4 +46,14 @@ impl InvalidStateTransitionErrorWasm {
     pub fn get_raw_state_transition(&self) -> JsValue {
         self.raw_state_transition.clone()
     }
+
+    // #[wasm_bindgen(js_name = valueOf)]
+    // pub fn value_of(&self) -> Result<JsValue, JsError> {
+    //     let errors = serde_json::to_value(&self.errors)
+    //         .map_err(|_| JsError::new("Can't serialize consensus errors to json"))?;
+    //     let ser = serde_wasm_bindgen::Serializer::json_compatible();
+    //     errors
+    //         .serialize(&ser)
+    //         .map_err(|_| JsError::new("Can't serialize consensus errors to json"))
+    // }
 }

package/src/state_transition/fee/operations/pre_calculated_operation.rs

@@ -1,9 +1,10 @@
 use crate::{fee::dummy_fee_result::DummyFeesResultWasm, utils::Inner};
+use dpp::fee::Credits;
 use dpp::platform_value::Error as PlatformValueError;
 use dpp::{
     state_transition::fee::{
         operations::{OperationLike, PreCalculatedOperation},
-        Credits, Refunds,
+        Refunds,
     },
     ProtocolError,
 };

package/src/state_transition/mod.rs

@@ -1,142 +1,140 @@
-use dpp::state_transition::state_transition_execution_context::StateTransitionExecutionContext;
-
-use dpp::state_transition::fee::operations::Operation;
-use wasm_bindgen::prelude::*;
-
+// use dpp::state_transition::fee::operations::Operation;
+// use wasm_bindgen::prelude::*;
+//
 pub mod errors;
-pub mod state_transition_facade;
+// pub mod state_transition_facade;
 pub mod state_transition_factory;
 
-pub mod fee;
-pub mod validation;
-use crate::state_transition::conversion::create_operation_from_wasm_instance;
-use crate::utils::Inner;
-pub use fee::*;
-pub use validation::*;
-
-pub(crate) mod conversion;
-
-#[wasm_bindgen(js_name=StateTransitionExecutionContext)]
-#[derive(Clone)]
-pub struct StateTransitionExecutionContextWasm(StateTransitionExecutionContext);
-
-impl From<StateTransitionExecutionContext> for StateTransitionExecutionContextWasm {
-    fn from(rs: StateTransitionExecutionContext) -> Self {
-        StateTransitionExecutionContextWasm(rs)
-    }
-}
-
-impl From<StateTransitionExecutionContextWasm> for StateTransitionExecutionContext {
-    fn from(wa: StateTransitionExecutionContextWasm) -> Self {
-        wa.0
-    }
-}
-
-impl<'a> From<&'a StateTransitionExecutionContextWasm> for StateTransitionExecutionContext {
-    fn from(wa: &StateTransitionExecutionContextWasm) -> Self {
-        wa.0.clone()
-    }
-}
-
-impl<'a> From<&'a StateTransitionExecutionContextWasm> for &'a StateTransitionExecutionContext {
-    fn from(wa: &'a StateTransitionExecutionContextWasm) -> Self {
-        &wa.0
-    }
-}
-
-impl<'a> From<&'a StateTransitionExecutionContext> for StateTransitionExecutionContextWasm {
-    fn from(rs: &'a StateTransitionExecutionContext) -> Self {
-        Self(rs.clone())
-    }
-}
-
-impl Default for StateTransitionExecutionContextWasm {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-#[wasm_bindgen(js_class=StateTransitionExecutionContext)]
-impl StateTransitionExecutionContextWasm {
-    #[wasm_bindgen(constructor)]
-    pub fn new() -> StateTransitionExecutionContextWasm {
-        StateTransitionExecutionContext::default().into()
-    }
-
-    #[wasm_bindgen(js_name=enableDryRun)]
-    pub fn enable_dry_run(&self) {
-        self.0.enable_dry_run();
-    }
-
-    #[wasm_bindgen(js_name=disableDryRun)]
-    pub fn disable_dry_run(&self) {
-        self.0.disable_dry_run();
-    }
-
-    #[wasm_bindgen(js_name=isDryRun)]
-    pub fn is_dry_run(&self) -> bool {
-        self.0.is_dry_run()
-    }
-
-    #[wasm_bindgen(js_name=addOperation)]
-    pub fn add_operation(&self, operation: JsValue) -> Result<(), JsValue> {
-        let operation = create_operation_from_wasm_instance(&operation)?;
-        self.0.add_operation(operation);
-        Ok(())
-    }
-
-    #[wasm_bindgen(js_name=getDryOperations)]
-    pub fn get_dry_operations(&self) -> Vec<JsValue> {
-        self.0
-            .get_dry_operations()
-            .iter()
-            .map(|operation| match operation {
-                Operation::PreCalculated(operation) => {
-                    PreCalculatedOperationWasm::from(operation.to_owned()).into()
-                }
-                Operation::Read(operation) => ReadOperationWasm::from(operation.to_owned()).into(),
-                Operation::SignatureVerification(operation) => {
-                    SignatureVerificationOperationWasm::from(operation.to_owned()).into()
-                }
-            })
-            .collect()
-    }
-
-    #[wasm_bindgen(js_name=getOperations)]
-    pub fn get_operation(&self) -> Vec<JsValue> {
-        self.0
-            .get_operations()
-            .iter()
-            .map(|operation| match operation {
-                Operation::PreCalculated(operation) => {
-                    PreCalculatedOperationWasm::from(operation.to_owned()).into()
-                }
-                Operation::Read(operation) => ReadOperationWasm::from(operation.to_owned()).into(),
-                Operation::SignatureVerification(operation) => {
-                    SignatureVerificationOperationWasm::from(operation.to_owned()).into()
-                }
-            })
-            .collect()
-    }
-
-    #[wasm_bindgen(js_name=clearDryOperations)]
-    pub fn clear_dry_run_operations(&self) {
-        self.0.clear_dry_run_operations();
-    }
-}
-
-impl Inner for StateTransitionExecutionContextWasm {
-    type InnerItem = StateTransitionExecutionContext;
-
-    fn into_inner(self) -> Self::InnerItem {
-        self.0
-    }
-
-    fn inner(&self) -> &Self::InnerItem {
-        &self.0
-    }
-
-    fn inner_mut(&mut self) -> &mut Self::InnerItem {
-        &mut self.0
-    }
-}
+// pub mod fee;
+// pub mod validation;
+// use crate::state_transition::conversion::create_operation_from_wasm_instance;
+// use crate::utils::Inner;
+// pub use fee::*;
+// pub use validation::*;
+//
+// pub(crate) mod conversion;
+//
+// #[wasm_bindgen(js_name=StateTransitionExecutionContext)]
+// #[derive(Clone)]
+// pub struct StateTransitionExecutionContextWasm(StateTransitionExecutionContext);
+//
+// impl From<StateTransitionExecutionContext> for StateTransitionExecutionContextWasm {
+//     fn from(rs: StateTransitionExecutionContext) -> Self {
+//         StateTransitionExecutionContextWasm(rs)
+//     }
+// }
+//
+// impl From<StateTransitionExecutionContextWasm> for StateTransitionExecutionContext {
+//     fn from(wa: StateTransitionExecutionContextWasm) -> Self {
+//         wa.0
+//     }
+// }
+//
+// impl<'a> From<&'a StateTransitionExecutionContextWasm> for StateTransitionExecutionContext {
+//     fn from(wa: &StateTransitionExecutionContextWasm) -> Self {
+//         wa.0.clone()
+//     }
+// }
+//
+// impl<'a> From<&'a StateTransitionExecutionContextWasm> for &'a StateTransitionExecutionContext {
+//     fn from(wa: &'a StateTransitionExecutionContextWasm) -> Self {
+//         &wa.0
+//     }
+// }
+//
+// impl<'a> From<&'a StateTransitionExecutionContext> for StateTransitionExecutionContextWasm {
+//     fn from(rs: &'a StateTransitionExecutionContext) -> Self {
+//         Self(rs.clone())
+//     }
+// }
+//
+// impl Default for StateTransitionExecutionContextWasm {
+//     fn default() -> Self {
+//         Self::new()
+//     }
+// }
+//
+// #[wasm_bindgen(js_class=StateTransitionExecutionContext)]
+// impl StateTransitionExecutionContextWasm {
+//     #[wasm_bindgen(constructor)]
+//     pub fn new() -> StateTransitionExecutionContextWasm {
+//         StateTransitionExecutionContext::default().into()
+//     }
+//
+//     #[wasm_bindgen(js_name=enableDryRun)]
+//     pub fn enable_dry_run(&self) {
+//         self.0.enable_dry_run();
+//     }
+//
+//     #[wasm_bindgen(js_name=disableDryRun)]
+//     pub fn disable_dry_run(&self) {
+//         self.0.disable_dry_run();
+//     }
+//
+//     #[wasm_bindgen(js_name=isDryRun)]
+//     pub fn is_dry_run(&self) -> bool {
+//         self.0.is_dry_run()
+//     }
+//
+//     #[wasm_bindgen(js_name=addOperation)]
+//     pub fn add_operation(&self, operation: JsValue) -> Result<(), JsValue> {
+//         let operation = create_operation_from_wasm_instance(&operation)?;
+//         self.0.add_operation(operation);
+//         Ok(())
+//     }
+//
+//     #[wasm_bindgen(js_name=getDryOperations)]
+//     pub fn get_dry_operations(&self) -> Vec<JsValue> {
+//         self.0
+//             .get_dry_operations()
+//             .iter()
+//             .map(|operation| match operation {
+//                 Operation::PreCalculated(operation) => {
+//                     PreCalculatedOperationWasm::from(operation.to_owned()).into()
+//                 }
+//                 Operation::Read(operation) => ReadOperationWasm::from(operation.to_owned()).into(),
+//                 Operation::SignatureVerification(operation) => {
+//                     SignatureVerificationOperationWasm::from(operation.to_owned()).into()
+//                 }
+//             })
+//             .collect()
+//     }
+//
+//     #[wasm_bindgen(js_name=getOperations)]
+//     pub fn get_operation(&self) -> Vec<JsValue> {
+//         self.0
+//             .get_operations()
+//             .iter()
+//             .map(|operation| match operation {
+//                 Operation::PreCalculated(operation) => {
+//                     PreCalculatedOperationWasm::from(operation.to_owned()).into()
+//                 }
+//                 Operation::Read(operation) => ReadOperationWasm::from(operation.to_owned()).into(),
+//                 Operation::SignatureVerification(operation) => {
+//                     SignatureVerificationOperationWasm::from(operation.to_owned()).into()
+//                 }
+//             })
+//             .collect()
+//     }
+//
+//     #[wasm_bindgen(js_name=clearDryOperations)]
+//     pub fn clear_dry_run_operations(&self) {
+//         self.0.clear_dry_run_operations();
+//     }
+// }
+//
+// impl Inner for StateTransitionExecutionContextWasm {
+//     type InnerItem = StateTransitionExecutionContext;
+//
+//     fn into_inner(self) -> Self::InnerItem {
+//         self.0
+//     }
+//
+//     fn inner(&self) -> &Self::InnerItem {
+//         &self.0
+//     }
+//
+//     fn inner_mut(&mut self) -> &mut Self::InnerItem {
+//         &mut self.0
+//     }
+// }

package/src/state_transition/state_transition_facade.rs

@@ -6,17 +6,19 @@ use crate::state_transition_factory::StateTransitionFactoryWasm;
 use crate::utils::{ToSerdeJSONExt, WithJsError};
 use crate::validation::ValidationResultWasm;
 use crate::{with_js_error, StateTransitionExecutionContextWasm};
-use dpp::state_transition::state_transition_execution_context::StateTransitionExecutionContext;
 use dpp::state_transition::{
-    StateTransitionConvert, StateTransitionFacade, StateTransitionType, ValidateOptions,
+    StateTransitionFacade, StateTransitionFieldTypes, StateTransitionType, ValidateOptions,
 };
 use dpp::version::ProtocolVersionValidator;
 use serde::Deserialize;
 
+use crate::errors::consensus::basic::state_transition::InvalidStateTransitionTypeErrorWasm;
 use crate::errors::protocol_error::from_protocol_error;
 use crate::errors::value_error::PlatformValueErrorWasm;
+
 use dpp::data_contract::state_transition::data_contract_update_transition::DataContractUpdateTransition;
 
+use num_enum::TryFromPrimitiveError;
 use std::sync::Arc;
 use wasm_bindgen::prelude::*;
 use wasm_bindgen::JsValue;
@@ -65,15 +67,13 @@ impl StateTransitionFacadeWasm {
             .get_integer::<u8>("type")
             .map_err(PlatformValueErrorWasm::from)?
             .try_into()
-            .map_err(|_| JsValue::from_str("Invalid state transition type"))?;
-
-        // TODO: clean values of other transitions as well?
-        match state_transition_type {
-            StateTransitionType::DataContractUpdate => {
-                DataContractUpdateTransition::clean_value(&mut raw_state_transition)
-                    .map_err(PlatformValueErrorWasm::from)?;
-            }
-            _ => {}
+            .map_err(|e: TryFromPrimitiveError<StateTransitionType>| {
+                InvalidStateTransitionTypeErrorWasm::new(e.number)
+            })?;
+
+        if state_transition_type == StateTransitionType::DataContractUpdate {
+            DataContractUpdateTransition::clean_value(&mut raw_state_transition)
+                .map_err(PlatformValueErrorWasm::from)?;
         }
 
         let result = self