@dashevo/wasm-dpp 0.25.0-dev.9 → 0.25.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dashevo/wasm-dpp",
-  "version": "0.25.0-dev.9",
+  "version": "0.25.1",
   "description": "The JavaScript implementation of the Dash Platform Protocol",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -43,17 +43,17 @@
     "@babel/cli": "^7.21.0",
     "@babel/core": "^7.15.5",
     "@babel/preset-env": "^7.15.4",
-    "@dashevo/dashcore-lib": "~0.20.3",
-    "@dashevo/dpns-contract": "0.25.0-dev.9",
-    "@dashevo/dpp": "0.25.0-dev.9",
-    "@dashevo/wasm-re2": "~1.0.2",
+    "@dashevo/dashcore-lib": "~0.20.9",
+    "@dashevo/dpns-contract": "0.25.1",
+    "@dashevo/dpp": "0.25.1",
+    "@dashevo/wasm-re2": "~2.0.4",
     "@types/bs58": "^4.0.1",
     "@types/node": "^14.6.0",
     "@yarnpkg/pnpify": "^4.0.0-rc.42",
     "ajv": "^8.6.0",
     "assert": "^2.0.0",
     "buffer": "^6.0.3",
-    "chai": "^4.3.4",
+    "chai": "^4.3.9",
     "chai-as-promised": "^7.1.1",
     "chai-exclude": "^2.1.0",
     "chai-string": "^1.5.0",

package/scripts/build-wasm.sh

@@ -1,46 +1,47 @@
 #!/usr/bin/env bash
+# shellcheck disable=SC2312
+set -ex
 
 TARGET=wasm32-unknown-unknown
 
-PROFILE_ARG=""
-PROFILE="debug"
-
-if [ -n "$CARGO_BUILD_PROFILE" ]; then
-    if [ "$CARGO_BUILD_PROFILE" == "release" ]; then
-      PROFILE_ARG="--release"
-      PROFILE="release"
-    elif [ "$CARGO_BUILD_PROFILE" != "debug" ]; then
-      PROFILE_ARG="--profile $CARGO_BUILD_PROFILE"
-      PROFILE="$CARGO_BUILD_PROFILE"
-    fi
+# "--profile release" is equivalent of "--release", see
+# https://github.com/rust-lang/cargo/blob/13413c64ff88dd6c2824e9eb9374fc5f10895d28/src/cargo/util/command_prelude.rs#L426
+CARGO_BUILD_PROFILE="${CARGO_BUILD_PROFILE:-dev}"
+PROFILE_ARG="--profile ${CARGO_BUILD_PROFILE}"
+PROFILE="${CARGO_BUILD_PROFILE}"
+if [[ "${CARGO_BUILD_PROFILE}" == "dev" ]]; then
+  PROFILE=debug
 fi
 
-OUTPUT_DIR="$PWD/wasm"
-OUTPUT_FILE="$OUTPUT_DIR/wasm_dpp_bg.wasm"
-BUILD_COMMAND="cargo build --config net.git-fetch-with-cli=true --target=$TARGET $PROFILE_ARG"
-BINDGEN_COMMAND="wasm-bindgen --out-dir=$OUTPUT_DIR --target=web --omit-default-module-path ../../target/$TARGET/$PROFILE/wasm_dpp.wasm"
+OUTPUT_DIR="${PWD}/wasm"
+# shellcheck disable=SC2034
+OUTPUT_FILE="${OUTPUT_DIR}/wasm_dpp_bg.wasm"
+BUILD_COMMAND="cargo build --config net.git-fetch-with-cli=true --target=${TARGET} ${PROFILE_ARG}"
+BINDGEN_COMMAND="wasm-bindgen --out-dir=${OUTPUT_DIR} --target=web --omit-default-module-path ../../target/${TARGET}/${PROFILE}/wasm_dpp.wasm"
 
-
-if ! [[ -d $OUTPUT_DIR ]];  then
-  mkdir -p "$OUTPUT_DIR"
+if ! [[ -d ${OUTPUT_DIR} ]]; then
+  mkdir -p "${OUTPUT_DIR}"
 fi
 
-if ! [ -x "$(command -v wasm-bindgen)" ]; then
-    echo 'Wasm-bindgen CLI is not installed. Installing';
-    cargo install -f wasm-bindgen-cli
+# TODO: Build wasm with build.rs
+# Meantime if you want to update wasm-bindgen you also need to update version in:
+#  - packages/wasm-dpp/Cargo.toml
+#  - Dockerfile
+if ! [[ -x "$(command -v wasm-bindgen)" ]]; then
+  echo "Wasm-bindgen CLI ${WASM_BINDGEN_VERSION} is not installed. Installing"
+  cargo install --config net.git-fetch-with-cli=true --profile "${CARGO_BUILD_PROFILE}" -f "wasm-bindgen-cli@0.2.86"
 fi
 
-
 # On a mac, bundled clang won't work - you need to install LLVM manually through brew,
 # and then set the correct env for the build to work
-if [[ "$OSTYPE" == "darwin"* ]]; then
-    AR_PATH=$(which llvm-ar)
-    CLANG_PATH=$(which clang)
-    AR=$AR_PATH CC=$CLANG_PATH $BUILD_COMMAND
-    AR=$AR_PATH CC=$CLANG_PATH $BINDGEN_COMMAND
+if [[ "${OSTYPE}" == "darwin"* ]]; then
+  AR_PATH=$(command -v llvm-ar)
+  CLANG_PATH=$(command -v clang)
+  AR=${AR_PATH} CC=${CLANG_PATH} ${BUILD_COMMAND}
+  AR=${AR_PATH} CC=${CLANG_PATH} ${BINDGEN_COMMAND}
 else
-    $BUILD_COMMAND
-    $BINDGEN_COMMAND
+  ${BUILD_COMMAND}
+  ${BINDGEN_COMMAND}
 fi
 
 # EMCC_CFLAGS="-s ERROR_ON_UNDEFINED_SYMBOLS=0 --no-entry" cargo build --target=wasm32-unknown-emscripten --release

package/src/bls_adapter.rs

@@ -1,4 +1,4 @@
-use dpp::dashcore::anyhow::anyhow;
+use anyhow::anyhow;
 use dpp::{BlsModule, PublicKeyValidationError};
 use wasm_bindgen::prelude::*;
 use wasm_bindgen::JsCast;

package/src/dash_platform_protocol.rs

@@ -1,244 +1,221 @@
 use std::sync::Arc;
-
 use wasm_bindgen::prelude::*;
 
-use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
+use crate::data_contract::DataContractFacadeWasm;
+use crate::document::factory::DocumentFactoryWASM;
 use crate::document_facade::DocumentFacadeWasm;
-use crate::fetch_and_validate_data_contract::DataContractFetcherAndValidatorWasm;
-use crate::identity_facade::IdentityFacadeWasm;
-use crate::state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper};
-use crate::DataContractFacadeWasm;
-use crate::{DocumentFactoryWASM, DocumentValidatorWasm};
-use dpp::identity::validation::PublicKeysValidator;
-
-use crate::state_transition_facade::StateTransitionFacadeWasm;
-use dpp::version::{ProtocolVersionValidator, COMPATIBILITY_MAP, LATEST_VERSION};
+use dpp::dash_platform_protocol::DashPlatformProtocol;
+use dpp::data_contract::DataContractFacade;
+use dpp::identity::IdentityFacade;
+use dpp::prelude::DataContract;
+use dpp::state_transition::state_transition_factory::StateTransitionFactory;
+use dpp::version::LATEST_VERSION;
 
 use crate::entropy_generator::ExternalEntropyGenerator;
-use serde::{Deserialize, Serialize};
+use crate::identity::identity_facade::IdentityFacadeWasm;
+use crate::state_transition::state_transition_factory::StateTransitionFactoryWasm;
+use crate::utils::WithJsError;
 
 #[wasm_bindgen(js_name=DashPlatformProtocol)]
-pub struct DashPlatformProtocol {
-    identity: IdentityFacadeWasm,
-    document: DocumentFacadeWasm,
-    data_contract: DataContractFacadeWasm,
-    state_transition: StateTransitionFacadeWasm,
-    protocol_version: u32,
-    state_repository: ExternalStateRepositoryLike,
-    public_keys_validator: Arc<PublicKeysValidator<BlsAdapter>>,
-    bls: BlsAdapter,
-    entropy_generator: ExternalEntropyGenerator,
-}
-
-#[derive(Serialize, Deserialize)]
-pub struct DPPOptions {
-    #[serde(rename = "protocolVersion")]
-    pub current_protocol_version: Option<u32>,
+pub struct DashPlatformProtocolWasm {
+    protocol: DashPlatformProtocol,
+    data_contracts: Arc<DataContractFacade>,
+    documents: DocumentFacadeWasm,
 }
 
 static mut LOGGER_INITIALIZED: bool = false;
 
 #[wasm_bindgen(js_class=DashPlatformProtocol)]
-impl DashPlatformProtocol {
+impl DashPlatformProtocolWasm {
     #[wasm_bindgen(constructor)]
     pub fn new(
-        bls_adapter: JsBlsAdapter,
-        state_repository: ExternalStateRepositoryLike,
         entropy_generator: ExternalEntropyGenerator,
         maybe_protocol_version: Option<u32>,
-    ) -> Result<DashPlatformProtocol, JsValue> {
+    ) -> Result<DashPlatformProtocolWasm, JsValue> {
         // Initialize logger only once to avoid repeating warnings
         // "attempted to set a logger after the logging system was already initialized"
         // Usage of unsafe is fine here as we are in a single-threaded JS environment
         unsafe {
-            if cfg!(LOGGER_INITIALIZED) && !LOGGER_INITIALIZED {
+            if !LOGGER_INITIALIZED {
                 LOGGER_INITIALIZED = true;
                 wasm_logger::init(wasm_logger::Config::new(log::Level::Debug));
             }
         }
 
-        let bls = BlsAdapter(bls_adapter);
         let protocol_version = maybe_protocol_version.unwrap_or(LATEST_VERSION);
-        let public_keys_validator = Arc::new(PublicKeysValidator::new(bls.clone()).unwrap());
+        let protocol = DashPlatformProtocol::new(protocol_version);
 
-        let (identity_facade, document_facade, data_contract_facade, state_transition_facade) =
-            create_facades(
-                public_keys_validator.clone(),
-                protocol_version,
-                state_repository.clone(),
-                bls.clone(),
-                entropy_generator.clone(),
-            )?;
+        let data_contracts = Arc::new(
+            DataContractFacade::new(protocol_version, Some(Box::new(entropy_generator.clone())))
+                .with_js_error()?,
+        );
 
-        Ok(Self {
-            document: document_facade,
-            identity: identity_facade,
-            data_contract: data_contract_facade,
-            state_transition: state_transition_facade,
-            protocol_version,
-            state_repository,
-            public_keys_validator,
-            bls,
-            entropy_generator,
+        let document_factory = DocumentFactoryWASM::new(protocol_version, Some(entropy_generator))?;
+
+        Ok(DashPlatformProtocolWasm {
+            protocol,
+            data_contracts,
+            documents: DocumentFacadeWasm::new(document_factory),
         })
     }
 
     #[wasm_bindgen(getter = dataContract)]
     pub fn data_contract(&self) -> DataContractFacadeWasm {
-        self.data_contract.clone()
+        DataContractFacadeWasm(Arc::clone(&self.data_contracts))
     }
 
     #[wasm_bindgen(getter=document)]
     pub fn document(&self) -> DocumentFacadeWasm {
-        self.document.clone()
+        self.documents.clone()
     }
 
     #[wasm_bindgen(getter = identity)]
     pub fn identity(&self) -> IdentityFacadeWasm {
-        self.identity.clone()
+        // TODO: think if it's possible to avoid cloning
+        self.protocol.identities().into()
     }
 
     #[wasm_bindgen(getter = stateTransition)]
-    pub fn state_transition(&self) -> StateTransitionFacadeWasm {
-        self.state_transition.clone()
-    }
-
-    #[wasm_bindgen(getter = protocolVersion)]
-    pub fn protocol_version(&self) -> u32 {
-        self.protocol_version
-    }
-
-    #[wasm_bindgen(js_name = getProtocolVersion)]
-    pub fn get_protocol_version(&self) -> u32 {
-        self.protocol_version()
-    }
-
-    #[wasm_bindgen(js_name = setProtocolVersion)]
-    pub fn set_protocol_version(&mut self, protocol_version: u32) -> Result<(), JsValue> {
-        self.init(
-            protocol_version,
-            self.state_repository.clone(),
-            self.bls.clone(),
-            self.entropy_generator.clone(),
-        )
-    }
-
-    #[wasm_bindgen(js_name = setStateRepository)]
-    pub fn set_state_repository(
-        &mut self,
-        state_repository: ExternalStateRepositoryLike,
-    ) -> Result<(), JsValue> {
-        self.init(
-            self.protocol_version,
-            state_repository,
-            self.bls.clone(),
-            self.entropy_generator.clone(),
-        )
-    }
-
-    #[wasm_bindgen(js_name = getStateRepository)]
-    pub fn get_state_repository(&self) -> ExternalStateRepositoryLike {
-        self.state_repository.clone()
-    }
-
-    fn init(
-        &mut self,
-        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;
-        self.identity = identity_facade;
-        self.document = document_facade;
-        self.data_contract = data_contract_facade;
-        self.state_transition = state_transition_facade;
-        self.state_repository = state_repository;
-
-        Ok(())
+    pub fn state_transition(&self) -> StateTransitionFactoryWasm {
+        self.protocol.state_transition().into()
     }
+    //
+    // #[wasm_bindgen(getter = protocolVersion)]
+    // pub fn protocol_version(&self) -> u32 {
+    //     self.protocol_version
+    // }
+    //
+    // #[wasm_bindgen(js_name = getProtocolVersion)]
+    // pub fn get_protocol_version(&self) -> u32 {
+    //     self.protocol_version()
+    // }
+    //
+    // #[wasm_bindgen(js_name = setProtocolVersion)]
+    // pub fn set_protocol_version(&mut self, protocol_version: u32) -> Result<(), JsValue> {
+    //     self.init(
+    //         protocol_version,
+    //         self.state_repository.clone(),
+    //         self.bls.clone(),
+    //         self.entropy_generator.clone(),
+    //     )
+    // }
+    //
+    // #[wasm_bindgen(js_name = setStateRepository)]
+    // pub fn set_state_repository(
+    //     &mut self,
+    //     state_repository: ExternalStateRepositoryLike,
+    // ) -> Result<(), JsValue> {
+    //     self.init(
+    //         self.protocol_version,
+    //         state_repository,
+    //         self.bls.clone(),
+    //         self.entropy_generator.clone(),
+    //     )
+    // }
+    //
+    // #[wasm_bindgen(js_name = getStateRepository)]
+    // pub fn get_state_repository(&self) -> ExternalStateRepositoryLike {
+    //     self.state_repository.clone()
+    // }
+    //
+    // fn init(
+    //     &mut self,
+    //     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;
+    //     self.identity = identity_facade;
+    //     self.document = document_facade;
+    //     self.data_contract = data_contract_facade;
+    //     self.state_transition = state_transition_facade;
+    //     self.state_repository = state_repository;
+    //
+    //     Ok(())
+    // }
 }
 
-fn create_facades(
-    public_keys_validator: Arc<PublicKeysValidator<BlsAdapter>>,
-    protocol_version: u32,
-    state_repository: ExternalStateRepositoryLike,
-    bls_adapter: BlsAdapter,
-    entropy_generator: ExternalEntropyGenerator,
-) -> Result<
-    (
-        IdentityFacadeWasm,
-        DocumentFacadeWasm,
-        DataContractFacadeWasm,
-        StateTransitionFacadeWasm,
-    ),
-    JsValue,
-> {
-    let wrapped_state_repository =
-        ExternalStateRepositoryLikeWrapper::new(state_repository.clone());
-    let protocol_version_validator = Arc::new(ProtocolVersionValidator::new(
-        protocol_version,
-        LATEST_VERSION,
-        COMPATIBILITY_MAP.clone(),
-    ));
-
-    let identity_facade =
-        IdentityFacadeWasm::new(protocol_version_validator.clone(), public_keys_validator);
-
-    let document_facade = init_document_facade(
-        protocol_version,
-        protocol_version_validator.clone(),
-        wrapped_state_repository,
-        entropy_generator.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)?;
-
-    Ok((
-        identity_facade,
-        document_facade,
-        data_contract_facade,
-        state_transition_facade,
-    ))
-}
-
-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(),
-    );
-
-    let data_contract_fetcher_and_validator =
-        DataContractFetcherAndValidatorWasm::new_with_state_repository_wrapper(state_repository);
-
-    DocumentFacadeWasm::new(
-        document_validator,
-        document_factory,
-        data_contract_fetcher_and_validator,
-    )
-}
+// fn create_facades(
+//     public_keys_validator: Arc<PublicKeysValidator<BlsAdapter>>,
+//     protocol_version: u32,
+//     state_repository: ExternalStateRepositoryLike,
+//     bls_adapter: BlsAdapter,
+//     entropy_generator: ExternalEntropyGenerator,
+// ) -> Result<
+//     (
+//         IdentityFacadeWasm,
+//         DocumentFacadeWasm,
+//         DataContractFacadeWasm,
+//         StateTransitionFacadeWasm,
+//     ),
+//     JsValue,
+// > {
+//     let wrapped_state_repository =
+//         ExternalStateRepositoryLikeWrapper::new(state_repository.clone());
+//     let protocol_version_validator = Arc::new(ProtocolVersionValidator::new(
+//         protocol_version,
+//         LATEST_VERSION,
+//         COMPATIBILITY_MAP.clone(),
+//     ));
+//
+//     let identity_facade =
+//         IdentityFacadeWasm::new(protocol_version_validator.clone(), public_keys_validator);
+//
+//     let document_facade = init_document_facade(
+//         protocol_version,
+//         protocol_version_validator.clone(),
+//         wrapped_state_repository,
+//         entropy_generator.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)?;
+//
+//     Ok((
+//         identity_facade,
+//         document_facade,
+//         data_contract_facade,
+//         state_transition_facade,
+//     ))
+// }
+//
+// 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(),
+//     );
+//
+//     let data_contract_fetcher_and_validator =
+//         DataContractFetcherAndValidatorWasm::new_with_state_repository_wrapper(state_repository);
+//
+//     DocumentFacadeWasm::new(
+//         document_validator,
+//         document_factory,
+//         data_contract_fetcher_and_validator,
+//     )
+// }