feat(wasm-dpp): DashPlatformProtocol tests

packages/wasm-dpp/src/dash_platform_protocol.rs

@@ -7,7 +7,7 @@ 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::{with_js_error, DataContractFacadeWasm};
+use crate::DataContractFacadeWasm;
 use crate::{DocumentFactoryWASM, DocumentValidatorWasm};
 use dpp::identity::validation::PublicKeysValidator;
 
@@ -22,6 +22,10 @@ pub struct DashPlatformProtocol {
     document: DocumentFacadeWasm,
     data_contract: DataContractFacadeWasm,
     state_transition: StateTransitionFacadeWasm,
+    protocol_version: u32,
+    state_repository: ExternalStateRepositoryLike,
+    public_keys_validator: Arc<PublicKeysValidator<BlsAdapter>>,
+    bls: BlsAdapter,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -34,47 +38,31 @@ pub struct DPPOptions {
 impl DashPlatformProtocol {
     #[wasm_bindgen(constructor)]
     pub fn new(
-        options: JsValue,
         bls_adapter: JsBlsAdapter,
         state_repository: ExternalStateRepositoryLike,
+        maybe_protocol_version: Option<u32>,
     ) -> Result<DashPlatformProtocol, JsValue> {
-        // TODO: wrap whole thing around rs-dpp/dash_platform_protocol?
-        let options: DPPOptions = with_js_error!(serde_wasm_bindgen::from_value(options))?;
-        let wrapped_state_repository =
-            ExternalStateRepositoryLikeWrapper::new(state_repository.clone());
-        let bls = BlsAdapter(bls_adapter.clone());
-
-        let protocol_version = options.current_protocol_version.unwrap_or(LATEST_VERSION);
-        let protocol_version_validator = Arc::new(ProtocolVersionValidator::new(
-            protocol_version,
-            LATEST_VERSION,
-            COMPATIBILITY_MAP.clone(),
-        ));
-        let public_keys_validator = Arc::new(PublicKeysValidator::new(bls).unwrap());
-
-        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,
-        );
-
-        let data_contract_facade =
-            DataContractFacadeWasm::new(protocol_version, protocol_version_validator.clone());
-
-        let state_transition_facade = StateTransitionFacadeWasm::new(
-            state_repository,
-            bls_adapter,
-            protocol_version_validator,
-        )?;
+        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 (identity_facade, document_facade, data_contract_facade, state_transition_facade) =
+            create_facades(
+                public_keys_validator.clone(),
+                protocol_version,
+                state_repository.clone(),
+                bls.clone(),
+            )?;
 
         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,
         })
     }
 
@@ -97,6 +85,107 @@ impl DashPlatformProtocol {
     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(),
+        )
+    }
+
+    #[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())
+    }
+
+    #[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,
+    ) -> 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,
+            )?;
+
+        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,
+) -> 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,
+    );
+
+    let data_contract_facade =
+        DataContractFacadeWasm::new(protocol_version, protocol_version_validator.clone());
+
+    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(

packages/wasm-dpp/src/state_transition/state_transition_facade.rs

@@ -1,4 +1,4 @@
-use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
+use crate::bls_adapter::BlsAdapter;
 
 use crate::state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper};
 use crate::state_transition_factory::StateTransitionFactoryWasm;
@@ -23,16 +23,14 @@ pub struct StateTransitionFacadeWasm(
 impl StateTransitionFacadeWasm {
     pub fn new(
         state_repository: ExternalStateRepositoryLike,
-        bls_adapter: JsBlsAdapter,
+        bls_adapter: BlsAdapter,
         protocol_version_validator: Arc<ProtocolVersionValidator>,
     ) -> Result<StateTransitionFacadeWasm, JsValue> {
         let state_repository_wrapper = ExternalStateRepositoryLikeWrapper::new(state_repository);
 
-        let adapter = BlsAdapter(bls_adapter);
-
         let state_transition_facade = StateTransitionFacade::new(
             state_repository_wrapper,
-            adapter,
+            bls_adapter,
             protocol_version_validator,
         )
         .with_js_error()?;

packages/wasm-dpp/test/integration/dataContract/DataContractFacade.spec.js

@@ -24,7 +24,7 @@ describe('DataContractFacade', () => {
 
   beforeEach(async () => {
     blsAdapter = await getBlsAdapterMock();
-    dpp = new DashPlatformProtocol(blsAdapter);
+    dpp = new DashPlatformProtocol(1, blsAdapter);
 
     dataContractJs = await getDataContractJSFixture();
     rawDataContract = dataContractJs.toObject();

packages/wasm-dpp/test/integration/document/DocumentFacade.spec.js

@@ -45,7 +45,7 @@ describe('DocumentFacade', () => {
     stateRepositoryMock.fetchDataContract.resolves(dataContract);
 
     blsAdapter = await getBlsAdapterMock();
-    dpp = new DashPlatformProtocol({}, blsAdapter, stateRepositoryMock);
+    dpp = new DashPlatformProtocol(blsAdapter, stateRepositoryMock, 1);
 
     documentsJs = getDocumentsFixture(dataContractJs);
     documents = documentsJs.map((d) => {

packages/wasm-dpp/test/integration/identity/IdentityFacade.spec.js

@@ -4,6 +4,7 @@ const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createSta
 const getInstantAssetLockProofFixture = require('@dashevo/dpp/lib/test/fixtures/getInstantAssetLockProofFixture');
 const getChainAssetLockProofFixture = require('@dashevo/dpp/lib/test/fixtures/getChainAssetLockProofFixture');
 const IdentityPublicKey = require('@dashevo/dpp/lib/identity/IdentityPublicKey');
+const getBlsAdapterMock = require('../../../lib/test/mocks/getBlsAdapterMock');
 
 const { default: loadWasmDpp } = require('../../../dist');
 
@@ -42,9 +43,7 @@ describe('IdentityFacade', () => {
       height: 42,
     });
 
-    dpp = new DashPlatformProtocol({
-      stateRepository: stateRepositoryMock,
-    });
+    dpp = new DashPlatformProtocol(getBlsAdapterMock(), stateRepositoryMock, 1);
 
     const chainAssetLockProofJS = getChainAssetLockProofFixture();
     const instantAssetLockProofJS = getInstantAssetLockProofFixture();

packages/wasm-dpp/test/integration/stateTransition/StateTransitionFacade.spec.js

@@ -108,7 +108,7 @@ describe('StateTransitionFacade', () => {
 
     const blsAdapter = await getBlsAdapterMock();
 
-    dpp = new DashPlatformProtocol({}, blsAdapter, stateRepositoryMock);
+    dpp = new DashPlatformProtocol(blsAdapter, stateRepositoryMock, 1);
   });
 
   describe('createFromObject', () => {

packages/wasm-dpp/test/unit/DashPlatformProtocol.spec.js

@@ -1,39 +1,26 @@
-const { default: Ajv } = require('ajv/dist/2020');
-
 const protocolVersion = require('@dashevo/dpp/lib/version/protocolVersion');
 
-const DashPlatformProtocol = require('@dashevo/dpp/lib/DashPlatformProtocol');
-const JsonSchemaValidator = require('@dashevo/dpp/lib/validation/JsonSchemaValidator');
-
-const createStateRepositoryMock = require('@dashevo/dpp/lib/test/mocks/createStateRepositoryMock');
+const createStateRepositoryMock = require('../../lib/test/mocks/createStateRepositoryMock');
+const getBlsAdapterMock = require('../../lib/test/mocks/getBlsAdapterMock');
+let { DashPlatformProtocol } = require('../..');
+const { default: loadWasmDpp } = require('../..');
 
 describe('DashPlatformProtocol', () => {
   let dpp;
   let stateRepositoryMock;
-  let jsonSchemaValidatorMock;
 
   beforeEach(async function beforeEach() {
+    ({ DashPlatformProtocol } = await loadWasmDpp());
     stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
-    jsonSchemaValidatorMock = {};
 
-    dpp = new DashPlatformProtocol({
-      stateRepository: stateRepositoryMock,
-      jsonSchemaValidator: jsonSchemaValidatorMock,
-    });
-    await dpp.initialize();
+    dpp = new DashPlatformProtocol(
+      getBlsAdapterMock(),
+      stateRepositoryMock,
+      protocolVersion.latestVersion,
+    );
   });
 
   describe('constructor', () => {
-    it('should create JsonSchemaValidator if not passed in options', async () => {
-      dpp = new DashPlatformProtocol();
-      await dpp.initialize();
-
-      const jsonSchemaValidator = dpp.getJsonSchemaValidator();
-
-      expect(jsonSchemaValidator).to.be.instanceOf(JsonSchemaValidator);
-      expect(jsonSchemaValidator.ajv).to.be.instanceOf(Ajv);
-    });
-
     it('should set default protocol version', () => {
       dpp = new DashPlatformProtocol();
 
@@ -49,14 +36,6 @@ describe('DashPlatformProtocol', () => {
     });
   });
 
-  describe('getJsonSchemaValidator', () => {
-    it('should return JsonSchemaValidator', () => {
-      const result = dpp.getJsonSchemaValidator();
-
-      expect(result).to.equal(jsonSchemaValidatorMock);
-    });
-  });
-
   describe('setProtocolVersion', () => {
     it('should set protocol version', () => {
       expect(dpp.protocolVersion).to.equal(protocolVersion.latestVersion);
@@ -69,11 +48,11 @@ describe('DashPlatformProtocol', () => {
 
   describe('getProtocolVersion', () => {
     it('should get protocol version', () => {
-      expect(dpp.getProtocolVersion()).to.equal(protocolVersion.latestVersion);
+      expect(dpp.protocolVersion).to.equal(protocolVersion.latestVersion);
 
       dpp.setProtocolVersion(42);
 
-      expect(dpp.getProtocolVersion()).to.equal(42);
+      expect(dpp.protocolVersion).to.equal(42);
     });
   });
 });