@dashevo/wasm-dpp 2.0.0-rc.1 → 2.0.0-rc.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashevo/wasm-dpp",
-  "version": "2.0.0-rc.1",
+  "version": "2.0.0-rc.2",
   "description": "The JavaScript implementation of the Dash Platform Protocol",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -44,7 +44,7 @@
     "@babel/core": "^7.26.10",
     "@babel/preset-env": "^7.26.9",
     "@dashevo/dashcore-lib": "~0.22.0",
-    "@dashevo/dpns-contract": "2.0.0-rc.1",
+    "@dashevo/dpns-contract": "2.0.0-rc.2",
     "@types/bs58": "^4.0.1",
     "@types/node": "^14.6.0",
     "@yarnpkg/pnpify": "^4.0.0-rc.42",

package/src/state_transition/errors/mod.rs

@@ -1 +1,2 @@
 pub mod invalid_state_transition_error;
+pub mod state_transition_is_not_active_error;

package/src/state_transition/errors/state_transition_is_not_active_error.rs

@@ -0,0 +1,79 @@
+use dpp::version::ProtocolVersion;
+use std::ops::RangeInclusive;
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name = StateTransitionIsNotActiveError)]
+pub struct StateTransitionIsNotActiveErrorWasm {
+    state_transition_type: String,
+    active_version_range_start: ProtocolVersion,
+    active_version_range_end: ProtocolVersion,
+    current_protocol_version: ProtocolVersion,
+}
+
+impl StateTransitionIsNotActiveErrorWasm {
+    pub fn new(
+        state_transition_type: String,
+        active_version_range: RangeInclusive<ProtocolVersion>,
+        current_protocol_version: ProtocolVersion,
+    ) -> Self {
+        Self {
+            state_transition_type,
+            active_version_range_start: *active_version_range.start(),
+            active_version_range_end: *active_version_range.end(),
+            current_protocol_version,
+        }
+    }
+}
+
+#[wasm_bindgen(js_class = StateTransitionIsNotActiveError)]
+impl StateTransitionIsNotActiveErrorWasm {
+    #[wasm_bindgen(js_name = getStateTransitionType)]
+    pub fn get_state_transition_type(&self) -> String {
+        self.state_transition_type.clone()
+    }
+
+    #[wasm_bindgen(js_name = getActiveVersionRangeStart)]
+    pub fn get_active_version_range_start(&self) -> u32 {
+        self.active_version_range_start
+    }
+
+    #[wasm_bindgen(js_name = getActiveVersionRangeEnd)]
+    pub fn get_active_version_range_end(&self) -> u32 {
+        self.active_version_range_end
+    }
+
+    #[wasm_bindgen(js_name = getCurrentProtocolVersion)]
+    pub fn get_current_protocol_version(&self) -> u32 {
+        self.current_protocol_version
+    }
+
+    #[wasm_bindgen(js_name = toObject)]
+    pub fn to_object(&self) -> JsValue {
+        let object = js_sys::Object::new();
+        js_sys::Reflect::set(
+            &object,
+            &"stateTransitionType".into(),
+            &self.state_transition_type.clone().into(),
+        )
+        .unwrap();
+        js_sys::Reflect::set(
+            &object,
+            &"activeVersionRangeStart".into(),
+            &JsValue::from(self.active_version_range_start),
+        )
+        .unwrap();
+        js_sys::Reflect::set(
+            &object,
+            &"activeVersionRangeEnd".into(),
+            &JsValue::from(self.active_version_range_end),
+        )
+        .unwrap();
+        js_sys::Reflect::set(
+            &object,
+            &"currentProtocolVersion".into(),
+            &JsValue::from(self.current_protocol_version),
+        )
+        .unwrap();
+        object.into()
+    }
+}

package/src/state_transition/state_transition_factory.rs

@@ -7,6 +7,7 @@ use crate::identity::state_transition::{
     IdentityUpdateTransitionWasm,
 };
 use crate::state_transition::errors::invalid_state_transition_error::InvalidStateTransitionErrorWasm;
+use crate::state_transition::errors::state_transition_is_not_active_error::StateTransitionIsNotActiveErrorWasm;
 use crate::voting::state_transition::masternode_vote_transition::MasternodeVoteTransitionWasm;
 use dpp::state_transition::errors::StateTransitionError;
 use dpp::state_transition::state_transition_factory::StateTransitionFactory;
@@ -70,6 +71,16 @@ impl StateTransitionFactoryWasm {
                     serde_wasm_bindgen::to_value(&raw_state_transition)?,
                 )
                 .into()),
+                StateTransitionError::StateTransitionIsNotActiveError {
+                    state_transition_type,
+                    active_version_range,
+                    current_protocol_version,
+                } => Err(StateTransitionIsNotActiveErrorWasm::new(
+                    state_transition_type,
+                    active_version_range,
+                    current_protocol_version,
+                )
+                .into()),
             },
             Err(other) => Err(from_dpp_err(other)),
         }