@dashevo/wasm-dpp 0.25.0-dev.16 → 0.25.0-dev.17

package/src/identity/state_transition/identity_update_transition/mod.rs

@@ -1,9 +1,9 @@
 pub use identity_update_transition::*;
 
-pub mod apply_identity_update_transition;
-pub mod identity_update_public_keys_validator;
+// pub mod apply_identity_update_transition;
+// pub mod identity_update_public_keys_validator;
 pub mod identity_update_transition;
-pub mod identity_update_transition_basic_validator;
-pub mod identity_update_transition_state_validator;
+// pub mod identity_update_transition_basic_validator;
+// pub mod identity_update_transition_state_validator;
 
 mod to_object;

package/src/identity/state_transition/identity_update_transition/to_object.rs

@@ -1,11 +1,9 @@
 use dpp::identity::KeyID;
+use dpp::state_transition::identity_update_transition::accessors::IdentityUpdateTransitionAccessorsV0;
+use dpp::state_transition::identity_update_transition::IdentityUpdateTransition;
+use dpp::state_transition::public_key_in_creation::IdentityPublicKeyInCreation;
 use dpp::state_transition::StateTransitionIdentitySigned;
-use dpp::{
-    identifier::Identifier,
-    identity::state_transition::identity_public_key_transitions::IdentityPublicKeyInCreation,
-    identity::state_transition::identity_update_transition::identity_update_transition::IdentityUpdateTransition,
-    state_transition::StateTransitionLike,
-};
+use dpp::{identifier::Identifier, state_transition::StateTransitionLike};
 use serde::Deserialize;
 use std::default::Default;
 
@@ -18,10 +16,9 @@ pub struct ToObjectOptions {
 #[derive(Default)]
 pub struct ToObject {
     pub transition_type: u8,
-    pub protocol_version: u32,
     pub revision: u32,
     pub signature: Option<Vec<u8>>,
-    pub signature_public_key_id: Option<KeyID>,
+    pub signature_public_key_id: KeyID,
     pub public_keys_disabled_at: Option<u64>,
     pub public_keys_to_add: Option<Vec<IdentityPublicKeyInCreation>>,
     pub public_key_ids_to_disable: Option<Vec<KeyID>>,
@@ -30,34 +27,33 @@ pub struct ToObject {
 
 pub fn to_object_struct(
     transition: &IdentityUpdateTransition,
-    options: ToObjectOptions,
+    options: &ToObjectOptions,
 ) -> ToObject {
     let mut to_object = ToObject {
-        transition_type: transition.get_type() as u8,
-        protocol_version: transition.get_protocol_version(),
-        revision: transition.get_revision() as u32,
-        identity_id: transition.get_identity_id().to_owned(),
+        transition_type: transition.state_transition_type() as u8,
+        revision: transition.revision() as u32,
+        identity_id: transition.identity_id().to_owned(),
         ..ToObject::default()
     };
 
     if !options.skip_signature.unwrap_or(false) {
-        let signature = Some(transition.get_signature().to_vec());
+        let signature = Some(transition.signature().to_vec());
         if let Some(signature) = &signature {
             if !signature.is_empty() {
-                to_object.signature_public_key_id = transition.get_signature_public_key_id()
+                to_object.signature_public_key_id = transition.signature_public_key_id()
             }
         }
         to_object.signature = signature;
     }
 
-    to_object.public_keys_disabled_at = transition.get_public_keys_disabled_at();
+    to_object.public_keys_disabled_at = transition.public_keys_disabled_at();
 
-    let public_keys_to_add = transition.get_public_keys_to_add();
+    let public_keys_to_add = transition.public_keys_to_add();
     if !public_keys_to_add.is_empty() {
         to_object.public_keys_to_add = Some(public_keys_to_add.to_owned());
     }
 
-    let public_key_ids_to_disable = transition.get_public_key_ids_to_disable();
+    let public_key_ids_to_disable = transition.public_key_ids_to_disable();
     if !public_key_ids_to_disable.is_empty() {
         to_object.public_key_ids_to_disable = Some(public_key_ids_to_disable.to_owned());
     }

package/src/identity/state_transition/mod.rs

@@ -3,7 +3,7 @@ pub use identity_create_transition::*;
 pub use identity_credit_transfer_transition::*;
 pub use identity_topup_transition::*;
 pub use identity_update_transition::*;
-pub use validate_public_key_signatures::*;
+// pub use validate_public_key_signatures::*;
 
 mod asset_lock_proof;
 mod identity_create_transition;
@@ -12,4 +12,4 @@ pub(crate) mod identity_public_key_transitions;
 mod identity_topup_transition;
 mod identity_update_transition;
 mod transition_types;
-mod validate_public_key_signatures;
+// mod validate_public_key_signatures;

package/src/lib.rs

@@ -2,32 +2,32 @@ extern crate core;
 
 pub use dash_platform_protocol::*;
 pub use data_contract::*;
-pub use data_contract_factory::*;
-pub use data_trigger::*;
+// pub use data_contract_factory::*;
+// pub use data_trigger::*;
 pub use document::*;
 pub use identity::*;
 pub use metadata::*;
-pub use state_transition::*;
+// pub use state_transition::*;
 
 mod dash_platform_protocol;
 mod data_contract;
 mod data_contract_factory;
-mod data_trigger;
+// mod data_trigger;
 mod document;
 pub mod errors;
 mod identifier;
 mod identity;
 mod metadata;
-mod state_repository;
+// mod state_repository;
 mod state_transition;
-mod version;
+// mod version;
 
 mod utils;
 
-mod bls_adapter;
+pub mod bls_adapter;
 mod buffer;
 mod entropy_generator;
-mod generate_temporary_ecdsa_private_key;
+// mod generate_temporary_ecdsa_private_key;
 mod lodash;
 mod protocol_version;
-mod validation;
+// mod validation;

package/src/metadata.rs

@@ -12,19 +12,19 @@ use dpp::util::json_value::JsonValueExt;
 #[derive(Clone, Debug)]
 pub struct MetadataWasm(Metadata);
 
-impl std::convert::From<Metadata> for MetadataWasm {
+impl From<Metadata> for MetadataWasm {
     fn from(v: Metadata) -> Self {
         MetadataWasm(v)
     }
 }
 
-impl std::convert::From<&MetadataWasm> for Metadata {
+impl From<&MetadataWasm> for Metadata {
     fn from(v: &MetadataWasm) -> Self {
         v.0.clone()
     }
 }
 
-impl std::convert::Into<Metadata> for MetadataWasm {
+impl Into<Metadata> for MetadataWasm {
     fn into(self) -> Metadata {
         self.0
     }

package/src/protocol_version.rs

@@ -1,7 +1,7 @@
-use dpp::version::LATEST_VERSION;
+use dpp::version::{PlatformVersion, LATEST_VERSION};
 use wasm_bindgen::prelude::wasm_bindgen;
 
 #[wasm_bindgen(js_name = getLatestProtocolVersion)]
 pub fn latest_protocol_version() -> u32 {
-    LATEST_VERSION
+    PlatformVersion::latest().protocol_version
 }

package/src/state_transition/errors/invalid_state_transition_error.rs

@@ -47,13 +47,13 @@ impl InvalidStateTransitionErrorWasm {
         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"))
-    }
+    // #[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,9 +6,8 @@ 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;