@dashevo/wasm-dpp 4.2.0-dev.9 → 5.0.0-beta.1

package/src/errors/consensus/signature/contract_bounded_key_non_batch_error.rs

@@ -0,0 +1,29 @@
+use dpp::consensus::codes::ErrorWithCode;
+use dpp::consensus::signature::ContractBoundedKeyNonBatchError;
+use dpp::consensus::ConsensusError;
+
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=ContractBoundedKeyNonBatchError)]
+pub struct ContractBoundedKeyNonBatchErrorWasm {
+    inner: ContractBoundedKeyNonBatchError,
+}
+
+impl From<&ContractBoundedKeyNonBatchError> for ContractBoundedKeyNonBatchErrorWasm {
+    fn from(e: &ContractBoundedKeyNonBatchError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+
+#[wasm_bindgen(js_class=ContractBoundedKeyNonBatchError)]
+impl ContractBoundedKeyNonBatchErrorWasm {
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        ConsensusError::from(self.inner.clone()).code()
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn message(&self) -> String {
+        self.inner.to_string()
+    }
+}

package/src/errors/consensus/signature/contract_bounded_key_out_of_bounds_error.rs

@@ -0,0 +1,29 @@
+use dpp::consensus::codes::ErrorWithCode;
+use dpp::consensus::signature::ContractBoundedKeyOutOfBoundsError;
+use dpp::consensus::ConsensusError;
+
+use wasm_bindgen::prelude::*;
+
+#[wasm_bindgen(js_name=ContractBoundedKeyOutOfBoundsError)]
+pub struct ContractBoundedKeyOutOfBoundsErrorWasm {
+    inner: ContractBoundedKeyOutOfBoundsError,
+}
+
+impl From<&ContractBoundedKeyOutOfBoundsError> for ContractBoundedKeyOutOfBoundsErrorWasm {
+    fn from(e: &ContractBoundedKeyOutOfBoundsError) -> Self {
+        Self { inner: e.clone() }
+    }
+}
+
+#[wasm_bindgen(js_class=ContractBoundedKeyOutOfBoundsError)]
+impl ContractBoundedKeyOutOfBoundsErrorWasm {
+    #[wasm_bindgen(js_name=getCode)]
+    pub fn get_code(&self) -> u32 {
+        ConsensusError::from(self.inner.clone()).code()
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn message(&self) -> String {
+        self.inner.to_string()
+    }
+}

package/src/errors/consensus/signature/mod.rs

@@ -9,3 +9,9 @@ pub use basic_ecdsa_error::*;
 pub use identity_not_found_error::*;
 pub use signature_should_not_be_present_error::*;
 pub use uncompressed_public_key_not_allowed_error::*;
+
+mod contract_bounded_key_non_batch_error;
+pub use contract_bounded_key_non_batch_error::ContractBoundedKeyNonBatchErrorWasm;
+
+mod contract_bounded_key_out_of_bounds_error;
+pub use contract_bounded_key_out_of_bounds_error::ContractBoundedKeyOutOfBoundsErrorWasm;

package/src/identity/identity.rs

@@ -10,7 +10,7 @@ use dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV
 use dpp::identity::{Identity, IdentityPublicKey, KeyID};
 use dpp::metadata::Metadata;
 use dpp::platform_value::ReplacementType;
-use dpp::serialization::PlatformDeserializable;
+use dpp::serialization::PlatformDeserializableUntrusted;
 use dpp::serialization::PlatformSerializable;
 use dpp::serialization::ValueConvertible;
 use dpp::version::PlatformVersion;
@@ -267,7 +267,8 @@ impl IdentityWasm {
     #[wasm_bindgen(js_name=fromBuffer)]
     pub fn from_buffer(buffer: Vec<u8>) -> Result<IdentityWasm, JsValue> {
         let identity: Identity =
-            PlatformDeserializable::deserialize_from_bytes(buffer.as_slice()).with_js_error()?;
+            PlatformDeserializableUntrusted::deserialize_from_bytes_untrusted(buffer.as_slice())
+                .with_js_error()?;
         Ok(identity.into())
     }
 }

package/src/identity/identity_public_key/mod.rs

@@ -11,7 +11,7 @@ use dpp::identity::identity_public_key::accessors::v0::{
 use dpp::identity::identity_public_key::hash::IdentityPublicKeyHashMethodsV0;
 use dpp::identity::{IdentityPublicKey, KeyID, TimestampMillis};
 use dpp::platform_value::{BinaryData, ReplacementType};
-use dpp::serialization::{PlatformDeserializable, PlatformSerializable, ValueConvertible};
+use dpp::serialization::{PlatformDeserializableUntrusted, PlatformSerializable, ValueConvertible};
 use dpp::ProtocolError;
 
 use dpp::version::PlatformVersion;
@@ -196,7 +196,8 @@ impl IdentityPublicKeyWasm {
     #[wasm_bindgen(js_name=fromBuffer)]
     pub fn from_buffer(buffer: Vec<u8>) -> Result<IdentityPublicKeyWasm, JsValue> {
         let key: IdentityPublicKey =
-            PlatformDeserializable::deserialize_from_bytes(buffer.as_slice()).with_js_error()?;
+            PlatformDeserializableUntrusted::deserialize_from_bytes_untrusted(buffer.as_slice())
+                .with_js_error()?;
         Ok(key.into())
     }
 }

package/src/identity/mod.rs

@@ -12,7 +12,7 @@ mod identity_public_key;
 // use dpp::identity::IdentityPublicKey;
 // use dpp::identity::{Identity, KeyID};
 // use dpp::metadata::Metadata;
-// use dpp::serialization::serialization_traits::{PlatformDeserializable, PlatformSerializable};
+// use dpp::serialization::serialization_traits::{PlatformDeserializableUntrusted, PlatformSerializable};
 // use dpp::{ ProtocolError};
 //
 // use crate::identifier::IdentifierWrapper;

package/src/state_transition/state_transition_factory.rs

@@ -89,6 +89,15 @@ impl StateTransitionFactoryWasm {
                 | StateTransition::IdentityTopUpFromShieldedPool(_) => Err(JsValue::from_str(
                     "shielded transitions are not yet supported in wasm-dpp StateTransitionFactory",
                 )),
+                StateTransition::IdentityKeyLimitsUpdate(_) => Err(JsValue::from_str(
+                    "identity key limits update transitions are not supported in wasm-dpp StateTransitionFactory; use wasm-dpp2",
+                )),
+                StateTransition::ContractUserModeration(_) => Err(JsValue::from_str(
+                    "contract user moderation transitions are not supported in wasm-dpp StateTransitionFactory; use wasm-dpp2",
+                )),
+                StateTransition::ContractFeeClaim(_) => Err(JsValue::from_str(
+                    "contract fee claim transitions are not supported in wasm-dpp StateTransitionFactory; use wasm-dpp2",
+                )),
             },
             Err(dpp::ProtocolError::StateTransitionError(e)) => match e {
                 StateTransitionError::InvalidStateTransitionError {

package/src/utils.rs

@@ -5,7 +5,7 @@ use anyhow::{anyhow, bail, Context};
 use dpp::{consensus::ConsensusError, ProtocolError};
 
 use dpp::platform_value::Value;
-use dpp::serialization::PlatformDeserializable;
+use dpp::serialization::PlatformDeserializableUntrusted;
 use js_sys::{Function, Uint8Array};
 use serde::de::DeserializeOwned;
 use serde_json::Value as JsonValue;
@@ -355,7 +355,7 @@ pub(crate) fn consensus_errors_from_buffers(
             .to_vec()
         })
         .map(|error_bytes| {
-            ConsensusError::deserialize_from_bytes(&error_bytes.to_vec()).with_js_error()
+            ConsensusError::deserialize_from_bytes_untrusted(&error_bytes.to_vec()).with_js_error()
         })
         .collect::<Result<Vec<ConsensusError>, JsValue>>()
 }

package/src/validation/validation_result.rs

@@ -4,7 +4,6 @@ use crate::{
 };
 
 use dpp::{consensus::ConsensusError, validation::ConsensusValidationResult};
-use js_sys::JsString;
 use wasm_bindgen::prelude::*;
 
 #[wasm_bindgen(js_name=ValidationResult)]
@@ -35,13 +34,6 @@ impl ValidationResultWasm {
         Ok(Self(ConsensusValidationResult::new_with_errors(vec![])))
     }
 
-    /// This is just a test method - doesn't need to be in the resulted binding. Please
-    /// remove before shipping
-    #[wasm_bindgen(js_name=errorsText)]
-    pub fn errors_text(&self) -> Vec<JsString> {
-        self.0.errors.iter().map(|e| e.to_string().into()).collect()
-    }
-
     #[wasm_bindgen(js_name=isValid)]
     pub fn is_valid(&self) -> bool {
         self.0.is_valid()

package/test/unit/dataContract/stateTransition/DataContractCreateTransition/DataContractCreateTransition.spec.js

@@ -72,7 +72,9 @@ describe('DataContractCreateTransition', () => {
     it('should return serialized State Transition', () => {
       const result = stateTransition.toBuffer();
       expect(result).to.be.instanceOf(Buffer);
-      expect(result).to.have.lengthOf(2370);
+      // The fixture contract carries a V2 config (protocol version 14), whose optional
+      // moderation declaration is one more bincode byte than a V1 config.
+      expect(result).to.have.lengthOf(2371);
     });
 
     it('should be able to restore contract config from bytes', () => {

package/test/unit/dataContract/stateTransition/DataContractUpdateTransition/DataContractUpdateTransition.spec.js

@@ -66,7 +66,9 @@ describe('DataContractUpdateTransition', () => {
     it('should return serialized State Transition', () => {
       const result = stateTransition.toBuffer();
       expect(result).to.be.instanceOf(Buffer);
-      expect(result).to.have.lengthOf(2370);
+      // The fixture contract carries a V2 config (protocol version 14), whose optional
+      // moderation declaration is one more bincode byte than a V1 config.
+      expect(result).to.have.lengthOf(2371);
     });
 
     it('should be able to restore contract config from bytes', () => {