chore: rs-dpp and wasm-dpp updates for integration

packages/rs-dpp/src/data_contract/data_contract_facade.rs

@@ -3,6 +3,7 @@ use crate::data_contract::validation::data_contract_validator::DataContractValid
 use crate::data_contract::{DataContract, DataContractFactory};
 
 use crate::prelude::Identifier;
+use crate::util::entropy_generator::EntropyGenerator;
 use crate::validation::SimpleValidationResult;
 use crate::version::ProtocolVersionValidator;
 use crate::ProtocolError;
@@ -29,6 +30,22 @@ impl DataContractFacade {
         }
     }
 
+    pub fn new_with_entropy_generator(
+        protocol_version: u32,
+        protocol_version_validator: Arc<ProtocolVersionValidator>,
+        entropy_generator: Box<dyn EntropyGenerator>,
+    ) -> Self {
+        let validator = Arc::new(DataContractValidator::new(protocol_version_validator));
+        Self {
+            factory: DataContractFactory::new_with_entropy_generator(
+                protocol_version,
+                validator.clone(),
+                entropy_generator,
+            ),
+            data_contract_validator: validator,
+        }
+    }
+
     /// Create Data Contract
     pub fn create(
         &self,

packages/rs-dpp/src/identity/state_transition/identity_create_transition/identity_create_transition.rs

@@ -125,6 +125,12 @@ impl IdentityCreateTransition {
             state_transition.set_asset_lock_proof(AssetLockProof::try_from(proof)?)?;
         }
 
+        if let Some(signature) =
+            transition_map.get_optional_binary_data(property_names::SIGNATURE)?
+        {
+            state_transition.set_signature(signature);
+        }
+
         state_transition.protocol_version =
             transition_map.get_integer(property_names::PROTOCOL_VERSION)?;
 

packages/wasm-dpp/lib/index.ts

@@ -5,27 +5,35 @@ import wasmBase from '../wasm/wasm_dpp_bg.js';
 import patchIdentifier from "./identifier/patchIdentifier";
 
 let isInitialized = false;
+let loadingPromise: Promise<void> | null = null;
 
 export default async function loadDpp() {
   if (isInitialized) {
-    return dpp_module;
-  } else {
-    // @ts-ignore
-    let bytes = Buffer.from(wasmBase, 'base64');
-
-    if (typeof fetch !== 'undefined') {
-      let blob = new Blob([bytes], { type: "application/wasm" });
-      let wasmUrl = URL.createObjectURL(blob);
-      await init(wasmUrl);
-      isInitialized = true;
-    } else {
-      dpp_module.initSync(bytes);
-      isInitialized = true;
-    }
-
-    patchIdentifier(dpp_module);
-
-    return dpp_module;
+    return dpp_module
+  }
+
+  if (!loadingPromise) {
+    loadingPromise = loadDppModule()
   }
+
+  await loadingPromise;
+  isInitialized = true;
+  loadingPromise = null;
+  return dpp_module;
 };
 
+const loadDppModule = async () => {
+  // @ts-ignore
+  let bytes = Buffer.from(wasmBase, 'base64');
+
+  if (typeof window !== 'undefined') {
+    let blob = new Blob([bytes], { type: "application/wasm" });
+    let wasmUrl = URL.createObjectURL(blob);
+    await init(wasmUrl);
+  } else {
+    dpp_module.initSync(bytes);
+  }
+
+  patchIdentifier(dpp_module);
+}
+

packages/wasm-dpp/src/dash_platform_protocol.rs

@@ -14,6 +14,7 @@ use dpp::identity::validation::PublicKeysValidator;
 use crate::state_transition_facade::StateTransitionFacadeWasm;
 use dpp::version::{ProtocolVersionValidator, COMPATIBILITY_MAP, LATEST_VERSION};
 
+use crate::entropy_generator::ExternalEntropyGenerator;
 use serde::{Deserialize, Serialize};
 
 #[wasm_bindgen(js_name=DashPlatformProtocol)]
@@ -26,6 +27,7 @@ pub struct DashPlatformProtocol {
     state_repository: ExternalStateRepositoryLike,
     public_keys_validator: Arc<PublicKeysValidator<BlsAdapter>>,
     bls: BlsAdapter,
+    entropy_generator: ExternalEntropyGenerator,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -40,6 +42,7 @@ impl DashPlatformProtocol {
     pub fn new(
         bls_adapter: JsBlsAdapter,
         state_repository: ExternalStateRepositoryLike,
+        entropy_generator: ExternalEntropyGenerator,
         maybe_protocol_version: Option<u32>,
     ) -> Result<DashPlatformProtocol, JsValue> {
         let bls = BlsAdapter(bls_adapter);
@@ -52,6 +55,7 @@ impl DashPlatformProtocol {
                 protocol_version,
                 state_repository.clone(),
                 bls.clone(),
+                entropy_generator.clone(),
             )?;
 
         Ok(Self {
@@ -63,6 +67,7 @@ impl DashPlatformProtocol {
             state_repository,
             public_keys_validator,
             bls,
+            entropy_generator,
         })
     }
 
@@ -102,6 +107,7 @@ impl DashPlatformProtocol {
             protocol_version,
             self.state_repository.clone(),
             self.bls.clone(),
+            self.entropy_generator.clone(),
         )
     }
 
@@ -110,7 +116,12 @@ impl DashPlatformProtocol {
         &mut self,
         state_repository: ExternalStateRepositoryLike,
     ) -> Result<(), JsValue> {
-        self.init(self.protocol_version, state_repository, self.bls.clone())
+        self.init(
+            self.protocol_version,
+            state_repository,
+            self.bls.clone(),
+            self.entropy_generator.clone(),
+        )
     }
 
     #[wasm_bindgen(js_name = getStateRepository)]
@@ -123,13 +134,15 @@ impl DashPlatformProtocol {
         protocol_version: u32,
         state_repository: ExternalStateRepositoryLike,
         bls_adapter: BlsAdapter,
+        entropy_generator: ExternalEntropyGenerator,
     ) -> Result<(), JsValue> {
         let (identity_facade, document_facade, data_contract_facade, state_transition_facade) =
             create_facades(
                 self.public_keys_validator.clone(),
                 protocol_version,
                 state_repository.clone(),
                 bls_adapter,
+                entropy_generator,
             )?;
 
         self.protocol_version = protocol_version;
@@ -148,6 +161,7 @@ fn create_facades(
     protocol_version: u32,
     state_repository: ExternalStateRepositoryLike,
     bls_adapter: BlsAdapter,
+    entropy_generator: ExternalEntropyGenerator,
 ) -> Result<
     (
         IdentityFacadeWasm,
@@ -172,10 +186,14 @@ fn create_facades(
         protocol_version,
         protocol_version_validator.clone(),
         wrapped_state_repository,
+        entropy_generator.clone(),
     );
 
-    let data_contract_facade =
-        DataContractFacadeWasm::new(protocol_version, protocol_version_validator.clone());
+    let data_contract_facade = DataContractFacadeWasm::new(
+        protocol_version,
+        protocol_version_validator.clone(),
+        entropy_generator,
+    );
 
     let state_transition_facade =
         StateTransitionFacadeWasm::new(state_repository, bls_adapter, protocol_version_validator)?;
@@ -192,12 +210,14 @@ fn init_document_facade(
     protocol_version: u32,
     protocol_version_validator: Arc<ProtocolVersionValidator>,
     state_repository: ExternalStateRepositoryLikeWrapper,
+    entropy_generator: ExternalEntropyGenerator,
 ) -> DocumentFacadeWasm {
     let document_validator = DocumentValidatorWasm::new_with_arc(protocol_version_validator);
 
     let document_factory = DocumentFactoryWASM::new_with_state_repository_wrapper(
         protocol_version,
         document_validator.clone(),
+        entropy_generator,
         state_repository.clone(),
     );
 

packages/wasm-dpp/src/data_contract/data_contract_facade.rs

@@ -8,6 +8,7 @@ use dpp::data_contract::DataContractFacade;
 use dpp::identifier::Identifier;
 use dpp::version::ProtocolVersionValidator;
 
+use crate::entropy_generator::ExternalEntropyGenerator;
 use crate::utils::{get_bool_from_options, WithJsError, SKIP_VALIDATION_PROPERTY_NAME};
 use crate::validation::ValidationResultWasm;
 use dpp::platform_value::Value;
@@ -23,8 +24,13 @@ impl DataContractFacadeWasm {
     pub fn new(
         protocol_version: u32,
         protocol_version_validator: Arc<ProtocolVersionValidator>,
+        entropy_generator: ExternalEntropyGenerator,
     ) -> Self {
-        let inner = DataContractFacade::new(protocol_version, protocol_version_validator);
+        let inner = DataContractFacade::new_with_entropy_generator(
+            protocol_version,
+            protocol_version_validator,
+            Box::new(entropy_generator),
+        );
 
         Self(Arc::new(inner))
     }

packages/wasm-dpp/src/data_contract/state_transition/data_contract_create_transition/mod.rs

@@ -6,6 +6,8 @@ use std::collections::HashMap;
 pub use apply::*;
 pub use validation::*;
 
+use dpp::consensus::signature::SignatureError;
+use dpp::consensus::ConsensusError::SignatureError as ConsensusSignatureErrorVariant;
 use dpp::{
     data_contract::state_transition::data_contract_create_transition::DataContractCreateTransition,
     platform_value,
@@ -161,6 +163,7 @@ impl DataContractCreateTransitionWasm {
         bls: JsBlsAdapter,
     ) -> Result<(), JsValue> {
         let bls_adapter = BlsAdapter(bls);
+
         self.0
             .sign(
                 &identity_public_key.to_owned().into(),
@@ -169,4 +172,31 @@ impl DataContractCreateTransitionWasm {
             )
             .with_js_error()
     }
+
+    #[wasm_bindgen(js_name=verifySignature)]
+    pub fn verify_signature(
+        &self,
+        identity_public_key: &IdentityPublicKeyWasm,
+        bls: JsBlsAdapter,
+    ) -> Result<bool, JsValue> {
+        let bls_adapter = BlsAdapter(bls);
+
+        let verification_result = self
+            .0
+            .verify_signature(&identity_public_key.to_owned().into(), &bls_adapter);
+
+        match verification_result {
+            Ok(()) => Ok(true),
+            Err(protocol_error) => match &protocol_error {
+                ProtocolError::AbstractConsensusError(err) => match err.as_ref() {
+                    ConsensusSignatureErrorVariant(
+                        SignatureError::InvalidStateTransitionSignatureError,
+                    ) => Ok(false),
+                    _ => Err(protocol_error),
+                },
+                _ => Err(protocol_error),
+            },
+        }
+        .with_js_error()
+    }
 }

packages/wasm-dpp/src/data_contract/state_transition/data_contract_update_transition/mod.rs

@@ -6,7 +6,10 @@ use std::collections::HashMap;
 pub use apply::*;
 pub use validation::*;
 
+use dpp::consensus::ConsensusError::SignatureError as ConsensusSignatureErrorVariant;
+
 use dpp::{
+    consensus::signature::SignatureError,
     data_contract::state_transition::data_contract_update_transition::DataContractUpdateTransition,
     platform_value,
     state_transition::{
@@ -17,7 +20,11 @@ use dpp::{
 use serde::{Deserialize, Serialize};
 use wasm_bindgen::prelude::*;
 
-use crate::utils::WithJsError;
+use crate::{
+    bls_adapter::{BlsAdapter, JsBlsAdapter},
+    utils::WithJsError,
+    IdentityPublicKeyWasm,
+};
 use crate::{
     buffer::Buffer, errors::protocol_error::from_protocol_error, identifier::IdentifierWrapper,
     with_js_error, DataContractParameters, DataContractWasm, StateTransitionExecutionContextWasm,
@@ -159,4 +166,31 @@ impl DataContractUpdateTransitionWasm {
             .serialize(&serde_wasm_bindgen::Serializer::json_compatible())
             .map_err(|e| e.into())
     }
+
+    #[wasm_bindgen(js_name=verifySignature)]
+    pub fn verify_signature(
+        &self,
+        identity_public_key: &IdentityPublicKeyWasm,
+        bls: JsBlsAdapter,
+    ) -> Result<bool, JsValue> {
+        let bls_adapter = BlsAdapter(bls);
+
+        let verification_result = self
+            .0
+            .verify_signature(&identity_public_key.to_owned().into(), &bls_adapter);
+
+        match verification_result {
+            Ok(()) => Ok(true),
+            Err(protocol_error) => match &protocol_error {
+                ProtocolError::AbstractConsensusError(err) => match err.as_ref() {
+                    ConsensusSignatureErrorVariant(
+                        SignatureError::InvalidStateTransitionSignatureError,
+                    ) => Ok(false),
+                    _ => Err(protocol_error),
+                },
+                _ => Err(protocol_error),
+            },
+        }
+        .with_js_error()
+    }
 }

packages/wasm-dpp/src/document/factory.rs

@@ -67,12 +67,14 @@ impl DocumentFactoryWASM {
     pub(crate) fn new_with_state_repository_wrapper(
         protocol_version: u32,
         document_validator: DocumentValidatorWasm,
+        entropy_generator: ExternalEntropyGenerator,
         state_repository: ExternalStateRepositoryLikeWrapper,
     ) -> Self {
-        let factory = DocumentFactory::new(
+        let factory = DocumentFactory::new_with_entropy_generator(
             protocol_version,
             document_validator.into(),
             DataContractFetcherAndValidator::new(Arc::new(state_repository)),
+            Box::new(entropy_generator),
         );
 
         DocumentFactoryWASM(factory)