@dashevo/wasm-dpp 0.25.6 → 0.25.9

package/src/identity/state_transition/asset_lock_proof/chain/chain_asset_lock_proof.rs

@@ -1,3 +1,6 @@
+use dpp::dashcore::consensus::Encodable;
+use dpp::dashcore::OutPoint;
+use dpp::identity::state_transition::asset_lock_proof::AssetLockProofType;
 use serde::{Deserialize, Serialize};
 use std::convert::TryInto;
 use wasm_bindgen::prelude::*;
@@ -10,8 +13,8 @@ use crate::{
     with_js_error,
 };
 use dpp::identity::state_transition::asset_lock_proof::chain::ChainAssetLockProof;
+use dpp::platform_value::string_encoding;
 use dpp::platform_value::string_encoding::Encoding;
-use dpp::platform_value::{string_encoding, Bytes36};
 
 #[wasm_bindgen(js_name=ChainAssetLockProof)]
 #[derive(Clone)]
@@ -20,8 +23,6 @@ pub struct ChainAssetLockProofWasm(ChainAssetLockProof);
 #[derive(Debug, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 struct ChainAssetLockProofParams {
-    #[serde(rename = "type")]
-    lock_type: u8,
     core_chain_locked_height: u32,
     out_point: Vec<u8>,
 }
@@ -41,14 +42,14 @@ impl From<ChainAssetLockProofWasm> for ChainAssetLockProof {
 #[wasm_bindgen(js_class = ChainAssetLockProof)]
 impl ChainAssetLockProofWasm {
     #[wasm_bindgen(constructor)]
-    pub fn new(raw_parameters: JsValue) -> Result<ChainAssetLockProofWasm, JsValue> {
-        let parameters: ChainAssetLockProofParams =
-            with_js_error!(serde_wasm_bindgen::from_value(raw_parameters))?;
+    pub fn new(raw_parameters: JsValue) -> Result<ChainAssetLockProofWasm, JsError> {
+        let parameters: ChainAssetLockProofParams = serde_wasm_bindgen::from_value(raw_parameters)
+            .map_err(|_| JsError::new("invalid raw chain lock proof"))?;
 
-        let out_point: [u8; 36] = parameters.out_point.try_into().map_err(|_| {
-            RustConversionError::Error(String::from("outPoint must be a 36 byte array"))
-                .to_js_value()
-        })?;
+        let out_point: [u8; 36] = parameters
+            .out_point
+            .try_into()
+            .map_err(|_| JsError::new("outPoint must be a 36 byte array"))?;
 
         let chain_asset_lock_proof =
             ChainAssetLockProof::new(parameters.core_chain_locked_height, out_point);
@@ -58,7 +59,7 @@ impl ChainAssetLockProofWasm {
 
     #[wasm_bindgen(js_name=getType)]
     pub fn get_type(&self) -> u8 {
-        ChainAssetLockProof::asset_lock_type()
+        AssetLockProofType::Chain as u8
     }
 
     #[wasm_bindgen(js_name=getCoreChainLockedHeight)]
@@ -72,8 +73,15 @@ impl ChainAssetLockProofWasm {
     }
 
     #[wasm_bindgen(js_name=getOutPoint)]
-    pub fn get_out_point(&self) -> Buffer {
-        Buffer::from_bytes_owned(self.0.out_point.to_vec())
+    pub fn get_out_point(&self) -> Result<Buffer, JsValue> {
+        let mut outpoint_bytes = Vec::new();
+
+        self.0
+            .out_point
+            .consensus_encode(&mut outpoint_bytes)
+            .map_err(|e| e.to_string())?;
+
+        Ok(Buffer::from_bytes_owned(outpoint_bytes))
     }
 
     #[wasm_bindgen(js_name=setOutPoint)]
@@ -82,7 +90,8 @@ impl ChainAssetLockProofWasm {
             RustConversionError::Error(String::from("outPoint must be a 36 byte array"))
                 .to_js_value()
         })?;
-        self.0.out_point = Bytes36::new(out_point);
+
+        self.0.out_point = OutPoint::from(out_point);
 
         Ok(())
     }
@@ -91,8 +100,14 @@ impl ChainAssetLockProofWasm {
     pub fn to_json(&self) -> Result<JsValue, JsValue> {
         let js_object = self.to_object()?;
 
-        let out_point_base64 =
-            string_encoding::encode(self.0.out_point.as_slice(), Encoding::Base64);
+        let mut outpoint_bytes = Vec::new();
+
+        self.0
+            .out_point
+            .consensus_encode(&mut outpoint_bytes)
+            .map_err(|e| e.to_string())?;
+
+        let out_point_base64 = string_encoding::encode(&outpoint_bytes, Encoding::Base64);
 
         js_sys::Reflect::set(
             &js_object,
@@ -110,7 +125,7 @@ impl ChainAssetLockProofWasm {
         let serializer = serde_wasm_bindgen::Serializer::json_compatible();
         let js_object = with_js_error!(asset_lock_value.serialize(&serializer))?;
 
-        let out_point = self.get_out_point();
+        let out_point = self.get_out_point()?;
 
         js_sys::Reflect::set(
             &js_object,

package/src/identity/state_transition/asset_lock_proof/instant/instant_asset_lock_proof.rs

@@ -3,6 +3,8 @@ use dpp::dashcore::{
     consensus::encode::serialize,
 };
 
+use dpp::dashcore::consensus::Encodable;
+use dpp::identity::state_transition::asset_lock_proof::AssetLockProofType;
 use serde::{Deserialize, Serialize};
 use std::convert::TryInto;
 use wasm_bindgen::prelude::*;
@@ -15,7 +17,7 @@ use crate::{
     with_js_error,
 };
 use dpp::identity::state_transition::asset_lock_proof::instant::{
-    InstantAssetLockProof, RawInstantLock,
+    InstantAssetLockProof, RawInstantLockProof,
 };
 use dpp::platform_value::string_encoding;
 use dpp::platform_value::string_encoding::Encoding;
@@ -51,34 +53,41 @@ impl From<InstantAssetLockProofWasm> for InstantAssetLockProof {
 #[wasm_bindgen(js_class = InstantAssetLockProof)]
 impl InstantAssetLockProofWasm {
     #[wasm_bindgen(constructor)]
-    pub fn new(raw_parameters: JsValue) -> Result<InstantAssetLockProofWasm, JsValue> {
-        let raw_instant_lock: RawInstantLock =
-            with_js_error!(serde_wasm_bindgen::from_value(raw_parameters))?;
+    pub fn new(raw_parameters: JsValue) -> Result<InstantAssetLockProofWasm, JsError> {
+        let raw_instant_lock: RawInstantLockProof = serde_wasm_bindgen::from_value(raw_parameters)
+            .map_err(|_| JsError::new("invalid raw instant lock proof"))?;
 
-        let instant_asset_lock_proof: InstantAssetLockProof =
-            raw_instant_lock.try_into().map_err(|_| {
-                RustConversionError::Error(String::from("object passed is not a raw Instant Lock"))
-                    .to_js_value()
-            })?;
+        let instant_asset_lock_proof: InstantAssetLockProof = raw_instant_lock
+            .try_into()
+            .map_err(|_| JsError::new("object passed is not a raw Instant Lock"))?;
 
         Ok(instant_asset_lock_proof.into())
     }
 
     #[wasm_bindgen(js_name=getType)]
     pub fn get_type(&self) -> u8 {
-        self.0.asset_lock_type()
+        AssetLockProofType::Instant as u8
     }
 
     #[wasm_bindgen(js_name=getOutputIndex)]
-    pub fn get_output_index(&self) -> usize {
+    pub fn get_output_index(&self) -> u32 {
         self.0.output_index()
     }
 
     #[wasm_bindgen(js_name=getOutPoint)]
-    pub fn get_out_point(&self) -> Option<Buffer> {
+    pub fn get_out_point(&self) -> Result<Option<Buffer>, JsValue> {
         self.0
             .out_point()
-            .map(|out_point| Buffer::from_bytes(&out_point))
+            .map(|out_point| {
+                let mut outpoint_bytes = Vec::new();
+
+                out_point
+                    .consensus_encode(&mut outpoint_bytes)
+                    .map_err(|e| e.to_string())?;
+
+                Ok(Buffer::from_bytes_owned(outpoint_bytes))
+            })
+            .transpose()
     }
 
     #[wasm_bindgen(js_name=getOutput)]

package/src/identity/state_transition/asset_lock_proof/mod.rs

@@ -56,7 +56,7 @@ pub trait AssetLockProofLike {
 impl AssetLockProofWasm {
     #[wasm_bindgen(constructor)]
     pub fn new(raw_asset_lock_proof: JsValue) -> Result<AssetLockProofWasm, JsValue> {
-        let lock_type = get_lock_type(&raw_asset_lock_proof)?;
+        let lock_type = get_type_from_raw_asset_lock_proof(&raw_asset_lock_proof)?;
 
         match lock_type {
             AssetLockProofType::Instant => {
@@ -93,21 +93,22 @@ impl AssetLockProofWasm {
     }
 }
 
-fn get_lock_type(raw_asset_lock_proof: &JsValue) -> Result<AssetLockProofType, JsValue> {
-    (js_sys::Reflect::get(raw_asset_lock_proof, &JsValue::from_str("type"))
-        .map_err(|_| {
-            RustConversionError::Error(String::from("error getting type from raw asset lock"))
-                .to_js_value()
-        })?
+fn get_type_from_raw_asset_lock_proof(
+    raw_asset_lock_proof: &JsValue,
+) -> Result<AssetLockProofType, JsError> {
+    let proof_type = js_sys::Reflect::get(raw_asset_lock_proof, &JsValue::from_str("type"))
+        .map_err(|_| JsError::new("error getting type from raw asset lock"))?
         .as_f64()
-        .ok_or_else(|| JsValue::from_str("asset lock type must be a number"))? as u64)
+        .ok_or_else(|| JsError::new("asset lock type must be a number"))?;
+
+    (proof_type as u64)
         .try_into()
-        .map_err(|_| JsValue::from_str("unrecognized asset lock proof type"))
+        .map_err(|_| JsError::new("unrecognized asset lock proof type"))
 }
 
 #[wasm_bindgen(js_name=createAssetLockProofInstance)]
-pub fn create_asset_lock_proof_instance(raw_parameters: JsValue) -> Result<JsValue, JsValue> {
-    let lock_type = get_lock_type(&raw_parameters)?;
+pub fn create_asset_lock_proof_instance(raw_parameters: JsValue) -> Result<JsValue, JsError> {
+    let lock_type = get_type_from_raw_asset_lock_proof(&raw_parameters)?;
 
     match lock_type {
         AssetLockProofType::Instant => {

package/src/identity/state_transition/identity_create_transition/identity_create_transition.rs

@@ -14,6 +14,7 @@ use dpp::version::PlatformVersion;
 use crate::identifier::IdentifierWrapper;
 
 use crate::identity::state_transition::asset_lock_proof::create_asset_lock_proof_from_wasm_instance;
+use dpp::identity::state_transition::AssetLockProved;
 
 use crate::{
     buffer::Buffer,

package/src/identity/state_transition/identity_create_transition/to_object.rs

@@ -1,4 +1,5 @@
 use dpp::identity::state_transition::asset_lock_proof::AssetLockProof;
+use dpp::identity::state_transition::AssetLockProved;
 use dpp::state_transition::identity_create_transition::accessors::IdentityCreateTransitionAccessorsV0;
 use dpp::state_transition::public_key_in_creation::IdentityPublicKeyInCreation;
 use dpp::{

package/src/identity/state_transition/identity_topup_transition/identity_topup_transition.rs

@@ -4,6 +4,7 @@ use std::default::Default;
 
 use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
 use crate::errors::from_dpp_err;
+use dpp::identity::state_transition::AssetLockProved;
 use dpp::identity::KeyType;
 use dpp::platform_value::BinaryData;
 use dpp::serialization::ValueConvertible;

package/src/identity/state_transition/identity_topup_transition/to_object.rs

@@ -1,4 +1,5 @@
 use dpp::identity::state_transition::asset_lock_proof::AssetLockProof;
+use dpp::identity::state_transition::AssetLockProved;
 use dpp::state_transition::identity_topup_transition::accessors::IdentityTopUpTransitionAccessorsV0;
 use dpp::state_transition::identity_topup_transition::IdentityTopUpTransition;
 use dpp::{identifier::Identifier, state_transition::StateTransitionLike};

package/src/lib.rs

@@ -30,4 +30,4 @@ mod entropy_generator;
 // mod generate_temporary_ecdsa_private_key;
 mod lodash;
 mod protocol_version;
-// mod validation;
+mod validation;

package/src/validation/mod.rs

@@ -1,5 +1,5 @@
-mod json_schema_validator;
+// mod json_schema_validator;
 mod validation_result;
 
-pub use json_schema_validator::*;
+// pub use json_schema_validator::*;
 pub use validation_result::*;

package/src/validation/validation_result.rs

@@ -75,21 +75,22 @@ impl ValidationResultWasm {
         }
     }
 
-    #[wasm_bindgen(js_name = addError)]
-    pub fn add_error_wasm(&mut self, error_buffer: Buffer) -> Result<JsValue, JsValue> {
-        let error_bytes: Vec<u8> = Uint8Array::new_with_byte_offset_and_length(
-            &error_buffer.buffer(),
-            error_buffer.byte_offset(),
-            error_buffer.length(),
-        )
-        .to_vec();
-
-        let consensus_error = ConsensusError::deserialize(&error_bytes).with_js_error()?;
-
-        self.0.add_error(consensus_error);
-
-        Ok(JsValue::undefined())
-    }
+    // TODO: restore?
+    // #[wasm_bindgen(js_name = addError)]
+    // pub fn add_error_wasm(&mut self, error_buffer: Buffer) -> Result<JsValue, JsValue> {
+    //     let error_bytes: Vec<u8> = Uint8Array::new_with_byte_offset_and_length(
+    //         &error_buffer.buffer(),
+    //         error_buffer.byte_offset(),
+    //         error_buffer.length(),
+    //     )
+    //     .to_vec();
+    //
+    //     let consensus_error = ConsensusError::deserialize(&error_bytes).with_js_error()?;
+    //
+    //     self.0.add_error(consensus_error);
+    //
+    //     Ok(JsValue::undefined())
+    // }
 }
 
 impl ValidationResultWasm {

package/test/integration/document/DocumentFacade.spec.js

@@ -1,48 +1,37 @@
 const crypto = require('crypto');
-const generateRandomIdentifier = require('../../../lib/test/fixtures/js/generateRandomIdentifier');
-const getDataContractFixture = require('../../../lib/test/fixtures/js/getDataContractFixture');
-const getDocumentsFixture = require('../../../lib/test/fixtures/js/getDocumentsFixture');
+const generateRandomIdentifier = require('../../../lib/test/utils/generateRandomIdentifierAsync');
+const getDataContractFixture = require('../../../lib/test/fixtures/getDataContractFixture');
+const getDocumentsFixture = require('../../../lib/test/fixtures/getDocumentsFixture');
 const createStateRepositoryMock = require('../../../lib/test/mocks/createStateRepositoryMock');
 
 const {
   ExtendedDocument,
   DataContract,
-  Identifier,
   ValidationResult,
   DocumentsBatchTransition,
   DashPlatformProtocol,
   DataContractNotPresentError,
-} = require('../../../dist');
-// const getBlsAdapterMock = require('../../../lib/test/mocks/getBlsAdapterMock');
-
-// let ExtendedDocument;
-// let DataContract;
-// let Identifier;
-// let ValidationResult;
-// let DocumentsBatchTransition;
-// let DashPlatformProtocol;
-// let DataContractNotPresentError;
+} = require('../../..');
 
 describe('DocumentFacade', () => {
   let dpp;
   let document;
   let documents;
-  let documentsJs;
   let dataContract;
   let ownerId;
   let stateRepositoryMock;
 
   beforeEach(async function beforeEach() {
-    const ownerIdJs = generateRandomIdentifier();
-    ownerId = new Identifier(ownerIdJs.toBuffer());
-    const dataContractJs = getDataContractFixture(ownerIdJs);
-    const dataContractObject = dataContractJs.toObject();
+    ownerId = await generateRandomIdentifier();
+    const dataContractFixture = await getDataContractFixture(ownerId.toBuffer());
+    const dataContractObject = dataContractFixture.toObject();
+
     dataContract = new DataContract({
       $format_version: '0',
-      id: dataContractObject.$id,
+      id: dataContractObject.id,
       version: 1,
       ownerId: dataContractObject.ownerId,
-      documentSchemas: dataContractObject.documents,
+      documentSchemas: dataContractObject.documentSchemas,
     });
 
     stateRepositoryMock = createStateRepositoryMock(this.sinonSandbox);
@@ -53,12 +42,7 @@ describe('DocumentFacade', () => {
       1,
     );
 
-    documentsJs = getDocumentsFixture(dataContractJs);
-    documents = documentsJs.map((d) => {
-      const currentDocument = new ExtendedDocument(d.toObject(), dataContract.clone());
-      currentDocument.setEntropy(d.entropy);
-      return currentDocument;
-    });
+    documents = await getDocumentsFixture(dataContract);
     ([document] = documents);
   });
 

package/test/integration/document/stateTransition/DocumentsBatchTransition/DocumentBatchTransition.spec.js

@@ -1,12 +1,10 @@
 const createStateRepositoryMock = require('../../../../../lib/test/mocks/createStateRepositoryMock');
-const getDataContractFixture = require('../../../../../lib/test/fixtures/js/getDataContractFixture');
-const getDocumentsFixture = require('../../../../../lib/test/fixtures/js/getDocumentsFixture');
+const getDataContractFixture = require('../../../../../lib/test/fixtures/getDataContractFixture');
+const getDocumentsFixture = require('../../../../../lib/test/fixtures/getDocumentsFixture');
 
 const { default: loadWasmDpp } = require('../../../../..');
 const { IdentityPublicKey } = require('../../../../..');
 
-let ExtendedDocument;
-let DataContract;
 let ProtocolVersionValidator;
 let DocumentValidator;
 let DocumentFactory;
@@ -23,30 +21,22 @@ describe('DocumentBatchTransition', () => {
 
   beforeEach(async function beforeEach() {
     ({
-      ExtendedDocument,
-      DataContract,
       ProtocolVersionValidator,
       DocumentFactory,
       DocumentValidator,
     } = await loadWasmDpp());
 
-    const dataContractFixtureJs = getDataContractFixture();
-
-    dataContractFixtureJs.documents.niceDocument
-      .signatureSecurityLevelRequirement = IdentityPublicKey.SECURITY_LEVELS.MEDIUM;
-    dataContractFixtureJs.documents.prettyDocument
-      .signatureSecurityLevelRequirement = IdentityPublicKey.SECURITY_LEVELS.MASTER;
-
-    dataContractFixture = new DataContract(dataContractFixtureJs.toObject());
+    dataContractFixture = await getDataContractFixture();
+    //
+    // dataContractFixtureJs.documents.niceDocument
+    //   .signatureSecurityLevelRequirement = IdentityPublicKey.SECURITY_LEVELS.MEDIUM;
+    // dataContractFixtureJs.documents.prettyDocument
+    //   .signatureSecurityLevelRequirement = IdentityPublicKey.SECURITY_LEVELS.MASTER;
 
     // 0 is niceDocument,
     // 1 and 2 are pretty documents,
     // 3 and 4 are indexed documents that do not have security level specified
-    documentsFixture = getDocumentsFixture(dataContractFixtureJs).map((doc) => {
-      const document = new ExtendedDocument(doc.toObject(), dataContractFixture.clone());
-      document.setEntropy(doc.entropy);
-      return document;
-    });
+    documentsFixture = await getDocumentsFixture(dataContractFixture);
 
     [
       mediumSecurityDocumentFixture, ,

package/test/integration/document/stateTransition/DocumentsBatchTransition/validation/basic/validateDocumentsBatchTransitionBasicFactory.spec.js

@@ -1,6 +1,6 @@
 const getDocumentTransitionsFixture = require('../../../../../../../lib/test/fixtures/getDocumentTransitionsFixture');
-const getDocumentsFixture = require('../../../../../../../lib/test/fixtures/js/getDocumentsFixture');
-const getDataContractFixture = require('../../../../../../../lib/test/fixtures/js/getDataContractFixture');
+const getDocumentsFixture = require('../../../../../../../lib/test/fixtures/getDocumentsFixture');
+const getDataContractFixture = require('../../../../../../../lib/test/fixtures/getDataContractFixture');
 const createStateRepositoryMock = require('../../../../../../../lib/test/mocks/createStateRepositoryMock');
 
 const { default: loadWasmDpp } = require('../../../../../../..');

package/test/integration/document/validation/validateDocumentFactory.spec.js

@@ -1,5 +1,5 @@
-const getDataContractFixture = require('../../../../lib/test/fixtures/js/getDataContractFixture');
-const getDocumentsFixture = require('../../../../lib/test/fixtures/js/getDocumentsFixture');
+const getDataContractFixture = require('../../../../lib/test/fixtures/getDataContractFixture');
+const getDocumentsFixture = require('../../../../lib/test/fixtures/getDocumentsFixture');
 
 const { expectJsonSchemaError, expectValidationError } = require('../../../../lib/test/expect/expectError');
 const { default: loadWasmDpp } = require('../../../../dist');

package/test/integration/identity/IdentityFacade.spec.js

@@ -24,8 +24,7 @@ describe('IdentityFacade', () => {
     );
 
     const chainAssetLockProofJS = getChainAssetLockProofFixture();
-    const instantAssetLockProofJS = await getInstantAssetLockProofFixture();
-    instantAssetLockProof = new InstantAssetLockProof(instantAssetLockProofJS.toObject());
+    instantAssetLockProof = await getInstantAssetLockProofFixture();
     chainAssetLockProof = new ChainAssetLockProof(chainAssetLockProofJS.toObject());
 
     identity = await getIdentityFixture(instantAssetLockProof.createIdentifier());

package/test/integration/identity/stateTransition/assetLockProof/instant/validateInstantAssetLockProofStructureFactory.spec.js

@@ -1,7 +1,7 @@
 const DashCoreLib = require('@dashevo/dashcore-lib');
 const { expect } = require('chai');
 
-const getInstantAssetLockFixture = require('../../../../../../lib/test/fixtures/js/getInstantAssetLockProofFixture');
+const getInstantAssetLockFixture = require('../../../../../../lib/test/fixtures/getInstantAssetLockProofFixture');
 const createStateRepositoryMock = require('../../../../../../lib/test/mocks/createStateRepositoryMock');
 const { expectJsonSchemaError, expectValidationError } = require('../../../../../../lib/test/expect/expectError');
 
@@ -36,7 +36,7 @@ describe.skip('validateInstantAssetLockProofStructureFactory', () => {
   });
 
   beforeEach(async function beforeEach() {
-    const assetLock = getInstantAssetLockFixture();
+    const assetLock = await getInstantAssetLockFixture();
     transaction = assetLock.getTransaction();
 
     rawProof = assetLock.toObject();

package/test/integration/identity/stateTransition/validatePublicKeySignaturesFactory.spec.js

@@ -2,9 +2,9 @@ const { PrivateKey, crypto: { Hash } } = require('@dashevo/dashcore-lib');
 
 const crypto = require('crypto');
 
-const BlsSignatures = require('@dashevo/dpp/lib/bls/bls');
-
 const { expect } = require('chai');
+const BlsSignatures = require('../../../../lib/bls/bls');
+
 const getIdentityCreateTransitionFixture = require('../../../../lib/test/fixtures/getIdentityCreateTransitionFixture');
 const { expectValidationError } = require('../../../../lib/test/expect/expectError');
 const getBlsAdapterMock = require('../../../../lib/test/mocks/getBlsAdapterMock');

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

@@ -1,5 +1,3 @@
-const JsDataContractUpdateTransition = require('@dashevo/dpp/lib/dataContract/stateTransition/DataContractUpdateTransition/DataContractUpdateTransition');
-
 const getDataContractFixture = require('../../../../../lib/test/fixtures/getDataContractFixture');
 const { default: loadWasmDpp } = require('../../../../..');
 const { StateTransitionTypes } = require('../../../../..');
@@ -81,12 +79,12 @@ describe('DataContractUpdateTransition', () => {
 
   describe.skip('#hash', () => {
     it('should return State Transition hash as hex', () => {
-      const jsStateTransition = new JsDataContractUpdateTransition(stateTransition.toJSON());
-
-      const result = stateTransition.hash();
-      const resultJs = jsStateTransition.hash();
-
-      expect(result).to.equal(resultJs);
+      // const jsStateTransition = new JsDataContractUpdateTransition(stateTransition.toJSON());
+      //
+      // const result = stateTransition.hash();
+      // const resultJs = jsStateTransition.hash();
+      //
+      // expect(result).to.equal(resultJs);
     });
   });