pshenmic-dpp 1.0.3 → 1.0.5

package/packages/private_key/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pshenmic_dpp_private_key"
-version = "0.1.0"
+version.workspace = true
 edition = "2024"
 
 [lib]
@@ -11,7 +11,4 @@ wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"] }
 dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
     "identity-value-conversion",
 ]}
-
-[profile.release]
-lto = true
-opt-level = 'z'
+pshenmic_dpp_enums = {path = "../enums"}

package/packages/private_key/src/lib.rs

@@ -1,4 +1,8 @@
 use dpp::dashcore::PrivateKey;
+use dpp::dashcore::hashes::hex::FromHex;
+use dpp::dashcore::key::Secp256k1;
+use dpp::dashcore::secp256k1::hashes::hex::{Case, DisplayHex};
+use pshenmic_dpp_enums::network::NetworkWASM;
 use wasm_bindgen::JsValue;
 use wasm_bindgen::prelude::wasm_bindgen;
 
@@ -7,8 +11,8 @@ pub struct PrivateKeyWASM(PrivateKey);
 
 #[wasm_bindgen]
 impl PrivateKeyWASM {
-    #[wasm_bindgen(constructor)]
-    pub fn new(wif: &str) -> Result<Self, JsValue> {
+    #[wasm_bindgen(js_name = "fromWIF")]
+    pub fn from_wif(wif: &str) -> Result<Self, JsValue> {
         let pk = PrivateKey::from_wif(wif).map_err(|err| JsValue::from_str(&*err.to_string()));
 
         match pk {
@@ -16,17 +20,51 @@ impl PrivateKeyWASM {
             Err(err) => Err(err),
         }
     }
+
+    #[wasm_bindgen(js_name = "fromBytes")]
+    pub fn from_bytes(bytes: Vec<u8>, js_network: JsValue) -> Result<Self, JsValue> {
+        let network = NetworkWASM::try_from(js_network)?;
+
+        let pk = PrivateKey::from_slice(bytes.as_slice(), network.into())
+            .map_err(|err| JsValue::from_str(&*err.to_string()))?;
+
+        Ok(PrivateKeyWASM(pk))
+    }
+
+    #[wasm_bindgen(js_name = "fromHex")]
+    pub fn from_hex(hex_key: &str, js_network: JsValue) -> Result<Self, JsValue> {
+        let network = NetworkWASM::try_from(js_network)?;
+
+        let bytes = Vec::from_hex(hex_key).map_err(|err| JsValue::from(err.to_string()))?;
+
+        let pk = PrivateKey::from_slice(bytes.as_slice(), network.into())
+            .map_err(|err| JsValue::from_str(&*err.to_string()))?;
+
+        Ok(PrivateKeyWASM(pk))
+    }
 }
 
 #[wasm_bindgen]
 impl PrivateKeyWASM {
-    #[wasm_bindgen(js_name = "getKeyWIF")]
-    pub fn get_key_wif(&self) -> String {
+    #[wasm_bindgen(js_name = "getWIF")]
+    pub fn get_wif(&self) -> String {
         self.0.to_wif()
     }
 
-    #[wasm_bindgen(js_name = "getKeyBytes")]
-    pub fn get_key_bytes(&self) -> Vec<u8> {
+    #[wasm_bindgen(js_name = "getBytes")]
+    pub fn get_bytes(&self) -> Vec<u8> {
         self.0.to_bytes()
     }
+
+    #[wasm_bindgen(js_name = "getHex")]
+    pub fn get_hex(&self) -> String {
+        self.0.to_bytes().to_hex_string(Case::Upper)
+    }
+
+    #[wasm_bindgen(js_name = "getPublicKeyHash")]
+    pub fn get_public_key_hash(&self) -> String {
+        let secp = Secp256k1::new();
+
+        self.0.public_key(&secp).pubkey_hash().to_hex()
+    }
 }

package/packages/state_transition/Cargo.toml

@@ -1,14 +1,14 @@
 [package]
 name = "pshenmic_dpp_state_transition"
-version = "0.1.0"
+version.workspace = true
 edition = "2024"
 
 [lib]
 crate-type = ["cdylib", "lib"]
 
 [dependencies]
-wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"] }
-pshenmic_dpp_public_key = {path = "../public_key"}
+wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"], default-features = false }
+pshenmic_dpp_public_key = {path = "../identity_public_key" }
 pshenmic_dpp_private_key = {path = "../private_key"}
 pshenmic_dpp_utils = {path = "../utils"}
 pshenmic_dpp_mock_bls = {path = "../mock_bls"}
@@ -16,7 +16,4 @@ pshenmic_dpp_enums = {path = "../enums"}
 dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
     "state-transition-signing"
 ]}
-
-[profile.release]
-lto = true
-opt-level = 'z'
+sha2 = "0.10.8"

package/packages/state_transition/src/lib.rs

@@ -1,14 +1,21 @@
-use dpp::identity::KeyType;
-use dpp::serialization::{PlatformDeserializable, PlatformSerializable};
+use dpp::dashcore::secp256k1::hashes::hex::Case::Lower;
+use dpp::dashcore::secp256k1::hashes::hex::DisplayHex;
+use dpp::identity::{KeyID, KeyType};
+use dpp::platform_value::BinaryData;
+use dpp::prelude::UserFeeIncrease;
+use dpp::serialization::{PlatformDeserializable, PlatformSerializable, Signable};
 use dpp::state_transition::StateTransition;
 use pshenmic_dpp_enums::keys::key_type::KeyTypeWASM;
+use pshenmic_dpp_enums::keys::purpose::PurposeWASM;
 use pshenmic_dpp_mock_bls::MockBLS;
 use pshenmic_dpp_private_key::PrivateKeyWASM;
 use pshenmic_dpp_public_key::IdentityPublicKeyWASM;
 use pshenmic_dpp_utils::WithJsError;
+use sha2::{Digest, Sha256};
 use wasm_bindgen::JsValue;
 use wasm_bindgen::prelude::wasm_bindgen;
 
+#[derive(Clone)]
 #[wasm_bindgen(js_name = "StateTransitionWASM")]
 pub struct StateTransitionWASM(StateTransition);
 
@@ -26,65 +33,55 @@ impl From<StateTransitionWASM> for StateTransition {
 
 #[wasm_bindgen]
 impl StateTransitionWASM {
-    #[wasm_bindgen(js_name=sign)]
+    #[wasm_bindgen(js_name = "sign")]
     pub fn sign(
         &mut self,
-        private_key: PrivateKeyWASM,
-        public_key: IdentityPublicKeyWASM,
-    ) -> Result<JsValue, JsValue> {
-        let sig = self.0.sign(
-            &public_key.into(),
-            private_key.get_key_bytes().as_slice(),
-            &MockBLS {},
-        );
-
-        let bytes = match sig {
-            Ok(_sig) => {
-                self.0.set_signature(self.0.signature().clone());
-                self.0
-                    .set_signature_public_key_id(self.0.signature_public_key_id().unwrap());
-                self.0.serialize_to_bytes()
-            }
-            Err(e) => wasm_bindgen::throw_str(&e.to_string()),
-        };
-
-        match bytes {
-            Ok(bytes) => Ok(JsValue::from(bytes.clone())),
-            Err(e) => Ok(JsValue::from_str(&format!("{}", e))),
-        }
+        private_key: &PrivateKeyWASM,
+        public_key: &IdentityPublicKeyWASM,
+    ) -> Result<Vec<u8>, JsValue> {
+        self.0
+            .sign(
+                &public_key.clone().into(),
+                private_key.get_bytes().as_slice(),
+                &MockBLS {},
+            )
+            .with_js_error()?;
+
+        self.0.set_signature(self.0.signature().clone());
+        self.0
+            .set_signature_public_key_id(self.0.signature_public_key_id().unwrap());
+
+        self.0.serialize_to_bytes().with_js_error()
     }
 
-    #[wasm_bindgen(js_name=signByPrivateKey)]
+    #[wasm_bindgen(js_name = "signByPrivateKey")]
     pub fn sign_by_private_key(
         &mut self,
-        private_key: PrivateKeyWASM,
-        key_type: KeyTypeWASM,
-    ) -> JsValue {
+        private_key: &PrivateKeyWASM,
+        js_key_type: JsValue,
+    ) -> Result<Vec<u8>, JsValue> {
+        let key_type = KeyTypeWASM::try_from(js_key_type)?;
+
         let _sig = self
             .0
             .sign_by_private_key(
-                &private_key.get_key_bytes().as_slice(),
+                &private_key.get_bytes().as_slice(),
                 KeyType::from(key_type),
                 &MockBLS {},
             )
             .with_js_error();
 
-        let bytes = self.0.serialize_to_bytes().with_js_error();
-
-        match bytes {
-            Ok(bytes) => JsValue::from(bytes.clone()),
-            Err(err) => err,
-        }
+        self.0.serialize_to_bytes().with_js_error()
     }
 
-    #[wasm_bindgen(js_name=toBytes)]
+    #[wasm_bindgen(js_name = "toBytes")]
     pub fn to_bytes(&self) -> Result<JsValue, JsValue> {
-        let bytes = self.0.serialize_to_bytes().expect("Serialization failed");
+        let bytes = self.0.serialize_to_bytes().with_js_error()?;
 
         Ok(JsValue::from(bytes.clone()))
     }
 
-    #[wasm_bindgen(js_name=fromBytes)]
+    #[wasm_bindgen(js_name = "fromBytes")]
     pub fn from_bytes(bytes: Vec<u8>) -> Result<StateTransitionWASM, JsValue> {
         let st = StateTransition::deserialize_from_bytes(bytes.as_slice());
 
@@ -93,4 +90,73 @@ impl StateTransitionWASM {
             Ok(transition) => Ok(StateTransitionWASM(transition)),
         }
     }
+
+    #[wasm_bindgen(js_name = "hash")]
+    pub fn get_hash(&self, skip_signature: bool) -> Result<String, JsValue> {
+        let payload: Vec<u8>;
+
+        if skip_signature {
+            payload = self.0.signable_bytes().with_js_error()?;
+        } else {
+            payload = dpp::serialization::PlatformSerializable::serialize_to_bytes(&self.0)
+                .with_js_error()?;
+        }
+
+        Ok(Sha256::digest(payload).to_hex_string(Lower))
+    }
+
+    #[wasm_bindgen(js_name = "getActionType")]
+    pub fn get_action_type(&self) -> String {
+        self.0.name()
+    }
+
+    #[wasm_bindgen(js_name = "getOwnerId")]
+    pub fn get_owner_id(&self) -> Vec<u8> {
+        self.0.owner_id().to_vec()
+    }
+
+    #[wasm_bindgen(getter = "signature")]
+    pub fn get_signature(&self) -> Vec<u8> {
+        self.0.signature().to_vec()
+    }
+
+    #[wasm_bindgen(getter = "signaturePublicKeyId")]
+    pub fn get_signature_public_key_id(&self) -> Option<KeyID> {
+        self.0.signature_public_key_id()
+    }
+
+    #[wasm_bindgen(getter = "userFeeIncrease")]
+    pub fn get_user_fee_increase(&self) -> UserFeeIncrease {
+        self.0.user_fee_increase()
+    }
+
+    #[wasm_bindgen(js_name = "getPurposeRequirement")]
+    pub fn get_purpose_requirement(&self) -> Option<Vec<String>> {
+        let requirements = self.0.purpose_requirement();
+
+        match requirements {
+            None => None,
+            Some(req) => Some(
+                req.iter()
+                    .map(|purpose| PurposeWASM::from(purpose.clone()))
+                    .map(String::from)
+                    .collect(),
+            ),
+        }
+    }
+
+    #[wasm_bindgen(setter = "signature")]
+    pub fn set_signature(&mut self, signature: Vec<u8>) {
+        self.0.set_signature(BinaryData::from(signature))
+    }
+
+    #[wasm_bindgen(setter = "signaturePublicKeyId")]
+    pub fn set_signature_public_key_id(&mut self, key_id: KeyID) {
+        self.0.set_signature_public_key_id(key_id)
+    }
+
+    #[wasm_bindgen(setter = "userFeeIncrease")]
+    pub fn set_user_fee_increase(&mut self, user_fee_increase: UserFeeIncrease) {
+        self.0.set_user_fee_increase(user_fee_increase)
+    }
 }

package/packages/utils/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pshenmic_dpp_utils"
-version = "0.1.0"
+version.workspace = true
 edition = "2024"
 
 [lib]
@@ -17,8 +17,3 @@ js-sys = "0.3.53"
 serde_json = { version = "1.0", features = ["preserve_order"] }
 serde-wasm-bindgen = { git = "https://github.com/QuantumExplorer/serde-wasm-bindgen", branch = "feat/not_human_readable" }
 serde = { version = "1.0.197", features = ["derive"] }
-itertools = { version = "0.13" }
-
-[profile.release]
-lto = true
-opt-level = 'z'

package/packages/utils/src/lib.rs

@@ -4,10 +4,9 @@ use anyhow::{Context, anyhow, bail};
 use dpp::ProtocolError;
 use dpp::identifier::Identifier;
 use dpp::platform_value::Value;
-use dpp::platform_value::string_encoding::Encoding;
+use dpp::platform_value::string_encoding::Encoding::Base58;
 use dpp::util::hash::hash_double_to_vec;
-use itertools::Itertools;
-use js_sys::Function;
+use js_sys::{Function, Uint8Array};
 use serde::de::DeserializeOwned;
 use serde_json::Value as JsonValue;
 use std::collections::BTreeMap;
@@ -274,7 +273,7 @@ pub fn generate_document_id_v0(
     owner_id: &Identifier,
     document_type_name: &str,
     entropy: &[u8],
-) -> Identifier {
+) -> Result<Identifier, JsValue> {
     let mut buf: Vec<u8> = vec![];
 
     buf.extend_from_slice(&contract_id.to_buffer());
@@ -282,7 +281,7 @@ pub fn generate_document_id_v0(
     buf.extend_from_slice(document_type_name.as_bytes());
     buf.extend_from_slice(entropy);
 
-    Identifier::from_bytes(&hash_double_to_vec(&buf)).unwrap()
+    Identifier::from_bytes(&hash_double_to_vec(&buf)).map_err(|e| JsValue::from(e.to_string()))
 }
 
 #[wasm_bindgen(raw_module = "../identifier_utils/Identifier.js")]
@@ -325,18 +324,21 @@ pub fn identifier_from_js_value(js_value: &JsValue) -> Result<Identifier, JsValu
         ));
     }
 
-    let value: serde_json::Value = js_value.with_serde_to_json_value()?;
-    match value {
-        serde_json::Value::Array(arr) => {
-            let bytes: Vec<u8> = arr.into_iter().map(value_to_u8).try_collect()?;
-            Identifier::from_bytes(&bytes)
-                .map_err(ProtocolError::ValueError)
-                .with_js_error()
-        }
-        serde_json::Value::String(string) => Identifier::from_string(&string, Encoding::Base58)
+    match js_value.is_string() {
+        true => Identifier::from_string(js_value.as_string().unwrap_or("".into()).as_str(), Base58)
             .map_err(ProtocolError::ValueError)
             .with_js_error(),
-        _ => Err(JsValue::from_str("Invalid ID. Expected array or string")),
+        false => match js_value.is_object() || js_value.is_array() {
+            true => {
+                let uint8_array = Uint8Array::from(js_value.clone());
+                let bytes = uint8_array.to_vec();
+
+                Identifier::from_bytes(&bytes)
+                    .map_err(ProtocolError::ValueError)
+                    .with_js_error()
+            }
+            false => Err(JsValue::from_str("Invalid ID. Expected array or string")),
+        },
     }
 }
 

package/scripts/build-js.sh

@@ -15,24 +15,26 @@ WASM_BINARY_PATH="$WASM_DIR/pshenmic_dpp_bg.wasm"
 # Create directory in dist to save transpiled wasm code and TS typings
 mkdir -p $DIST_WASM_DIR
 
-## Converting wasm into base64 and saving it to dist folder
 
 rm -rf $DIST_WASM_BINARY_BASE_64
 rm -rf $DIST_WASM_BINARY_RAW
 rm -rf $DIST_WASM_JS
 
+## Converting wasm into base64 and saving it to dist folder
+
 if [[ "${RAW}" == "true" ]]; then
   cp $WASM_BINARY_PATH $DIST_WASM_BINARY_RAW
 else
   echo "Converting wasm binary into base64 module"
   WASM_BUILD_BASE_64=$(base64 -i "$WASM_BINARY_PATH")
-  echo 'module.exports = "'${WASM_BUILD_BASE_64}'"' > "$DIST_WASM_BINARY_BASE_64"
+  echo 'export default "'${WASM_BUILD_BASE_64}'"' > "$DIST_WASM_BINARY_BASE_64"
 fi
 
-## Transpile ES Modules code to Common JS
-## and save directly to dist folder to avoid re-generating TS declarations
-echo "Transpiling wasm ES Modules to CommonJS"
+echo "Copying ES module to dist"
 cp $WASM_JS_CODE_PATH $DIST_WASM_JS
 
 echo "Cleaning wasm build"
-rm -rf $WASM_DIR
+rm -rf $WASM_DIR
+
+echo "Total build size: "
+du -sh $DIST_WASM_DIR

package/scripts/build.sh

@@ -9,6 +9,8 @@ PROFILE=release
 
 OUTPUT_FILE="${PWD}/wasm/pshenmic_dpp_bg.wasm"
 
+RUSTFLAGS="-C target-feature=+crt-static -C embed-bitcode=no -C metadata=reduced -C link-dead-code=no -C panic=abort"
+
 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 ${PWD}/target/${TARGET}/${PROFILE}/pshenmic_dpp.wasm"
 
@@ -28,7 +30,26 @@ fi
 
 if command -v wasm-opt &> /dev/null; then
   echo "Optimizing wasm using Binaryen"
-  wasm-opt -tnh --flatten --rereloop -Oz --gufa -Oz --gufa -Oz  "$OUTPUT_FILE" -o "${OUTPUT_FILE}"
+  wasm-opt \
+    --generate-global-effects \
+    -Oz \
+    -tnh \
+    --flatten \
+    --rereloop \
+    -Oz \
+    --converge \
+    --vacuum \
+    --dce \
+    --inlining-optimizing \
+    --merge-blocks \
+    --simplify-locals \
+    --optimize-instructions \
+    -Oz \
+    --gufa \
+    -Oz \
+    "$OUTPUT_FILE" \
+    -o \
+    "${OUTPUT_FILE}"
 else
   echo "wasm-opt command not found. Skipping wasm optimization."
 fi

package/src/lib.rs

@@ -1,9 +1,16 @@
 #![no_std]
 #![no_main]
 
+extern crate wee_alloc;
+
+// allows to save 7 kb
+#[global_allocator]
+static ALLOC: wee_alloc::WeeAlloc = wee_alloc::WeeAlloc::INIT;
+
 pub use pshenmic_dpp_data_contract;
-pub use pshenmic_dpp_document_batch;
+pub use pshenmic_dpp_data_contract_transitions;
 pub use pshenmic_dpp_document_search;
+pub use pshenmic_dpp_documents_batch;
 pub use pshenmic_dpp_enums;
 pub use pshenmic_dpp_identity;
 pub use pshenmic_dpp_identity_transitions;

package/tests/DataContract.spec.js

@@ -0,0 +1,175 @@
+const assert = require('assert')
+const { describe, it, before } = require('mocha')
+const initWasm = require('./utils/wasm')
+const { value, id, ownerId } = require('./mocks/DataContract')
+const { PlatformVersionWASM } = require('../dist/cjs/wasm/pshenmic_dpp')
+const { base58 } = require('@scure/base')
+const { fromHexString } = require('./utils/hex')
+
+let wasm
+
+let dataContractsBytes
+
+describe('DataContract', function () {
+  before(async function () {
+    wasm = initWasm()
+
+    dataContractsBytes = ['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']
+  })
+
+  describe('serialization / deserialization', function () {
+    it('should allows to create DataContract from schema without full validation', function () {
+      const dataContract = new wasm.DataContractWASM(value.ownerId, BigInt(2), value.documentSchemas, null, false)
+
+      assert.notEqual(dataContract.__wbg_ptr, 0)
+    })
+
+    it('should allows to create DataContract from schema with full validation', function () {
+      const dataContract = new wasm.DataContractWASM(value.ownerId, BigInt(2), value.documentSchemas, null, true)
+
+      assert.notEqual(dataContract.__wbg_ptr, 0)
+    })
+
+    it('should allows to create DataContract from value with full validation and without platform version', function () {
+      const dataContract = wasm.DataContractWASM.fromValue(value, true)
+
+      assert.notEqual(dataContract.__wbg_ptr, 0)
+    })
+
+    it('should allows to convert DataContract to bytes and from bytes', function () {
+      const [dataContractBytes] = dataContractsBytes
+
+      const dataContract = wasm.DataContractWASM.fromValue(value, true)
+
+      assert.deepEqual(dataContract.toBytes(), fromHexString(dataContractBytes))
+
+      const dataContractFromBytes = wasm.DataContractWASM.fromBytes(dataContract.toBytes(), false, PlatformVersionWASM.PLATFORM_V1)
+
+      assert.notEqual(dataContract.__wbg_ptr, 0)
+
+      assert.deepEqual(dataContractFromBytes.toBytes(), fromHexString(dataContractBytes))
+    })
+
+    it('should allows to create DataContract from bytes without full validation', function () {
+      const [dataContractBytes] = dataContractsBytes
+
+      const dataContractFromBytes = wasm.DataContractWASM.fromBytes(fromHexString(dataContractBytes), false, PlatformVersionWASM.PLATFORM_V1)
+      const dataContractFromValue = wasm.DataContractWASM.fromValue(value, true)
+
+      assert.deepEqual(dataContractFromBytes.toValue(), dataContractFromValue.toValue())
+    })
+
+    it('should allows to create DataContract from bytes with full validation and without version', function () {
+      const [dataContractBytes] = dataContractsBytes
+
+      const dataContractFromBytes = wasm.DataContractWASM.fromBytes(fromHexString(dataContractBytes), true)
+      const dataContractFromValue = wasm.DataContractWASM.fromValue(value, true)
+
+      assert.deepEqual(dataContractFromBytes.toValue(), dataContractFromValue.toValue())
+    })
+
+    it('should allow to get json', function () {
+      const dataContract = wasm.DataContractWASM.fromValue(value, true)
+
+      assert.deepEqual(dataContract.toJson(), value)
+    })
+  })
+
+  describe('getters', function () {
+    it('should allow to get schemas', function () {
+      const dataContract = wasm.DataContractWASM.fromValue(value, true)
+
+      assert.deepEqual(dataContract.getSchema(), value.documentSchemas)
+    })
+
+    it('should allow to get version', function () {
+      const dataContract = wasm.DataContractWASM.fromValue(value, true)
+
+      assert.deepEqual(dataContract.getVersion(), value.version)
+    })
+
+    it('should allow to get id', function () {
+      const dataContract = wasm.DataContractWASM.fromValue(value, true)
+
+      assert.deepEqual(dataContract.getId(), base58.decode(id))
+    })
+
+    it('should allow to get owner id', function () {
+      const dataContract = wasm.DataContractWASM.fromValue(value, true)
+
+      assert.deepEqual(dataContract.getOwnerId(), base58.decode(ownerId))
+    })
+
+    it('should allow to get config', function () {
+      const dataContract = wasm.DataContractWASM.fromValue(value, true)
+
+      assert.deepEqual(dataContract.getConfig(), value.config)
+    })
+  })
+
+  describe('setters', function () {
+    it('should allow to set id', function () {
+      const dataContract = wasm.DataContractWASM.fromValue(value, true)
+
+      const valueId = base58.decode('7ckT6Y19HnjfqoPFmfL995i4z2HwgZ8UttNmP99LtCBH')
+
+      dataContract.setId(Array.from(valueId))
+
+      assert.deepEqual(dataContract.getId(), valueId)
+    })
+
+    it('should allow to set owner id', function () {
+      const dataContract = wasm.DataContractWASM.fromValue(value, true)
+
+      const valueId = base58.decode('3bx13Wd5k4LwHAvXJrayc5HdKPyiccKWYECPQGGYfnVL')
+
+      dataContract.setOwnerId('3bx13Wd5k4LwHAvXJrayc5HdKPyiccKWYECPQGGYfnVL')
+
+      assert.deepEqual(dataContract.getOwnerId(), valueId)
+    })
+
+    it('should allow to set version', function () {
+      const dataContract = wasm.DataContractWASM.fromValue(value, true)
+
+      dataContract.setVersion(20)
+
+      assert.equal(dataContract.getVersion(), 20)
+    })
+
+    it('should allow to set config', function () {
+      const dataContract = wasm.DataContractWASM.fromValue(value, true)
+
+      const oldConfig = dataContract.getConfig()
+
+      const newConfig = { ...oldConfig, canBeDeleted: !oldConfig.canBeDeleted }
+
+      dataContract.setConfig(newConfig)
+
+      assert.deepEqual(dataContract.getConfig(), newConfig)
+    })
+
+    it('should allow to set schema', function () {
+      const dataContract = wasm.DataContractWASM.fromValue(value, true)
+
+      const oldSchema = dataContract.getSchema()
+
+      const newSchema = {
+        pupup: oldSchema.withdrawal
+      }
+
+      dataContract.setSchema(newSchema)
+
+      assert.deepEqual(dataContract.getSchema(), newSchema)
+    })
+  })
+
+  describe('static', function () {
+    it('should allow to generate id', function () {
+      const id = wasm.DataContractWASM.generateId('3bx13Wd5k4LwHAvXJrayc5HdKPyiccKWYECPQGGYfnVL', BigInt(4))
+
+      const valueId = base58.decode('7ckT6Y19HnjfqoPFmfL995i4z2HwgZ8UttNmP99LtCBH')
+
+      assert.deepEqual(id, valueId)
+    })
+  })
+})