pshenmic-dpp 1.0.5 → 1.0.6

package/packages/identity_transitions/src/top_up_transition/mod.rs

@@ -0,0 +1,141 @@
+use dpp::identifier::Identifier;
+use dpp::identity::state_transition::{AssetLockProved, OptionallyAssetLockProved};
+use dpp::prelude::UserFeeIncrease;
+use dpp::serialization::{PlatformDeserializable, PlatformSerializable, Signable};
+use dpp::state_transition::identity_topup_transition::IdentityTopUpTransition;
+use dpp::state_transition::identity_topup_transition::accessors::IdentityTopUpTransitionAccessorsV0;
+use dpp::state_transition::identity_topup_transition::v0::IdentityTopUpTransitionV0;
+use dpp::state_transition::{StateTransition, StateTransitionLike};
+use pshenmic_dpp_asset_lock_proof::AssetLockProofWASM;
+use pshenmic_dpp_identifier::IdentifierWASM;
+use pshenmic_dpp_state_transition::StateTransitionWASM;
+use pshenmic_dpp_utils::WithJsError;
+use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name = "IdentityTopUpTransitionWASM")]
+#[derive(Clone)]
+pub struct IdentityTopUpTransitionWASM(IdentityTopUpTransition);
+
+#[wasm_bindgen]
+impl IdentityTopUpTransitionWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        asset_lock_proof: &AssetLockProofWASM,
+        js_identity_id: JsValue,
+        user_fee_increase: UserFeeIncrease,
+    ) -> Result<IdentityTopUpTransitionWASM, JsValue> {
+        let identity_id: Identifier = IdentifierWASM::try_from(js_identity_id)?.into();
+
+        Ok(IdentityTopUpTransitionWASM(IdentityTopUpTransition::V0(
+            IdentityTopUpTransitionV0 {
+                asset_lock_proof: asset_lock_proof.clone().into(),
+                identity_id,
+                user_fee_increase,
+                signature: Default::default(),
+            },
+        )))
+    }
+
+    #[wasm_bindgen(js_name = "getModifiedDataIds")]
+    pub fn get_modified_data_ids(&self) -> Vec<IdentifierWASM> {
+        self.0
+            .modified_data_ids()
+            .iter()
+            .map(|id| id.clone().into())
+            .collect()
+    }
+
+    #[wasm_bindgen(js_name = "getOptionalAssetLockProof")]
+    pub fn get_optional_asset_lock_proof(&self) -> JsValue {
+        match self.0.optional_asset_lock_proof() {
+            Some(asset_lock) => JsValue::from(AssetLockProofWASM::from(asset_lock.clone())),
+            None => JsValue::null(),
+        }
+    }
+
+    #[wasm_bindgen(getter = "userFeeIncrease")]
+    pub fn get_user_fee_increase(&self) -> UserFeeIncrease {
+        self.0.user_fee_increase()
+    }
+
+    #[wasm_bindgen(getter = "identityIdentifier")]
+    pub fn get_identity_identifier(&self) -> IdentifierWASM {
+        self.0.identity_id().clone().into()
+    }
+
+    #[wasm_bindgen(getter = "assetLockProof")]
+    pub fn get_asset_lock_proof(&self) -> AssetLockProofWASM {
+        self.0.asset_lock_proof().clone().into()
+    }
+
+    #[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);
+    }
+
+    #[wasm_bindgen(setter = "identityIdentifier")]
+    pub fn set_identity_identifier(
+        &mut self,
+        js_identity_identifier: &JsValue,
+    ) -> Result<(), JsValue> {
+        let identity_identifier: Identifier =
+            IdentifierWASM::try_from(js_identity_identifier)?.into();
+        Ok(self.0.set_identity_id(identity_identifier.clone().into()))
+    }
+
+    #[wasm_bindgen(setter = "assetLockProof")]
+    pub fn set_asset_lock_proof(
+        &mut self,
+        asset_lock_proof: &AssetLockProofWASM,
+    ) -> Result<(), JsValue> {
+        self.0
+            .set_asset_lock_proof(asset_lock_proof.clone().into())
+            .with_js_error()
+    }
+
+    #[wasm_bindgen(getter = "signature")]
+    pub fn get_signature(&self) -> Vec<u8> {
+        self.0.signature().to_vec()
+    }
+
+    #[wasm_bindgen(js_name = "getSignableBytes")]
+    pub fn get_signable_bytes(&self) -> Result<Vec<u8>, JsValue> {
+        self.0.signable_bytes().with_js_error()
+    }
+
+    #[wasm_bindgen(setter = "signature")]
+    pub fn set_signature(&mut self, signature: Vec<u8>) {
+        self.0.set_signature_bytes(signature)
+    }
+
+    #[wasm_bindgen(js_name = "toBytes")]
+    pub fn to_bytes(&self) -> Result<Vec<u8>, JsValue> {
+        self.0.serialize_to_bytes().with_js_error()
+    }
+
+    #[wasm_bindgen(js_name = "fromBytes")]
+    pub fn from_bytes(bytes: Vec<u8>) -> Result<IdentityTopUpTransitionWASM, JsValue> {
+        let rs_transition =
+            IdentityTopUpTransition::deserialize_from_bytes(bytes.as_slice()).with_js_error()?;
+
+        Ok(IdentityTopUpTransitionWASM(rs_transition))
+    }
+
+    #[wasm_bindgen(js_name = "toStateTransition")]
+    pub fn to_state_transition(&self) -> StateTransitionWASM {
+        StateTransitionWASM::from(StateTransition::from(self.0.clone()))
+    }
+
+    #[wasm_bindgen(js_name = "fromStateTransition")]
+    pub fn from_state_transition(
+        st: StateTransitionWASM,
+    ) -> Result<IdentityTopUpTransitionWASM, JsValue> {
+        let rs_st: StateTransition = st.into();
+
+        match rs_st {
+            StateTransition::IdentityTopUp(st) => Ok(IdentityTopUpTransitionWASM(st)),
+            _ => Err(JsValue::from_str(&"Invalid state transition type)")),
+        }
+    }
+}

package/packages/identity_transitions/src/update_transition/mod.rs

@@ -0,0 +1,213 @@
+use crate::public_key_in_creation::IdentityPublicKeyInCreationWASM;
+use dpp::identity::KeyID;
+use dpp::identity::state_transition::OptionallyAssetLockProved;
+use dpp::prelude::{IdentityNonce, Revision, UserFeeIncrease};
+use dpp::serialization::{PlatformDeserializable, PlatformSerializable, Signable};
+use dpp::state_transition::identity_update_transition::IdentityUpdateTransition;
+use dpp::state_transition::identity_update_transition::accessors::IdentityUpdateTransitionAccessorsV0;
+use dpp::state_transition::identity_update_transition::v0::IdentityUpdateTransitionV0;
+use dpp::state_transition::public_key_in_creation::IdentityPublicKeyInCreation;
+use dpp::state_transition::{StateTransition, StateTransitionIdentitySigned, StateTransitionLike};
+use pshenmic_dpp_asset_lock_proof::AssetLockProofWASM;
+use pshenmic_dpp_enums::keys::purpose::PurposeWASM;
+use pshenmic_dpp_identifier::IdentifierWASM;
+use pshenmic_dpp_state_transition::StateTransitionWASM;
+use pshenmic_dpp_utils::WithJsError;
+use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name = "IdentityUpdateTransitionWASM")]
+#[derive(Clone)]
+pub struct IdentityUpdateTransitionWASM(IdentityUpdateTransition);
+
+#[wasm_bindgen]
+impl IdentityUpdateTransitionWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        js_identity_id: &JsValue,
+        revision: Revision,
+        nonce: IdentityNonce,
+        user_fee_increase: Option<UserFeeIncrease>,
+        js_add_public_keys: &js_sys::Array,
+        disable_public_keys: Vec<KeyID>,
+    ) -> Result<IdentityUpdateTransitionWASM, JsValue> {
+        let identity_id = IdentifierWASM::try_from(js_identity_id)?;
+
+        let add_public_keys: Vec<IdentityPublicKeyInCreationWASM> =
+            IdentityPublicKeyInCreationWASM::vec_from_js_value(js_add_public_keys)?;
+
+        Ok(IdentityUpdateTransitionWASM(IdentityUpdateTransition::V0(
+            IdentityUpdateTransitionV0 {
+                identity_id: identity_id.into(),
+                revision,
+                nonce,
+                add_public_keys: add_public_keys
+                    .clone()
+                    .iter()
+                    .map(|key| key.clone().into())
+                    .collect(),
+                disable_public_keys,
+                user_fee_increase: user_fee_increase.unwrap_or(0),
+                signature_public_key_id: 0,
+                signature: Default::default(),
+            },
+        )))
+    }
+
+    #[wasm_bindgen(getter = "revision")]
+    pub fn get_revision(&self) -> Revision {
+        self.0.revision()
+    }
+
+    #[wasm_bindgen(getter = "nonce")]
+    pub fn get_nonce(&self) -> IdentityNonce {
+        self.0.nonce()
+    }
+
+    #[wasm_bindgen(getter = "identityIdentifier")]
+    pub fn get_identity_identifier(&self) -> IdentifierWASM {
+        self.0.identity_id().into()
+    }
+
+    #[wasm_bindgen(js_name = "getPurposeRequirement")]
+    pub fn get_purpose_requirement(&self) -> Vec<String> {
+        self.0
+            .purpose_requirement()
+            .iter()
+            .map(|purpose| PurposeWASM::from(purpose.clone()).into())
+            .collect()
+    }
+
+    #[wasm_bindgen(js_name = "getModifiedDataIds")]
+    pub fn get_modified_data_ids(&self) -> Vec<IdentifierWASM> {
+        self.0
+            .modified_data_ids()
+            .iter()
+            .map(|id| id.clone().into())
+            .collect()
+    }
+
+    #[wasm_bindgen(js_name = "getOptionalAssetLockProof")]
+    pub fn get_optional_asset_lock_proof(&self) -> JsValue {
+        match self.0.optional_asset_lock_proof() {
+            Some(asset_lock) => JsValue::from(AssetLockProofWASM::from(asset_lock.clone())),
+            None => JsValue::null(),
+        }
+    }
+
+    #[wasm_bindgen(getter = "publicKeyIdsToDisable")]
+    pub fn get_public_key_ids_to_disable(&self) -> Vec<KeyID> {
+        self.0.public_key_ids_to_disable().to_vec()
+    }
+
+    #[wasm_bindgen(getter = "publicKeyIdsToAdd")]
+    pub fn get_public_key_ids_to_add(&self) -> Vec<IdentityPublicKeyInCreationWASM> {
+        self.0
+            .public_keys_to_add()
+            .to_vec()
+            .iter()
+            .map(|id| id.clone().into())
+            .collect()
+    }
+
+    #[wasm_bindgen(getter = "userFeeIncrease")]
+    pub fn get_user_fee_increase(&self) -> UserFeeIncrease {
+        self.0.user_fee_increase()
+    }
+
+    #[wasm_bindgen(setter = "revision")]
+    pub fn set_revision(&mut self, revision: Revision) {
+        self.0.set_revision(revision);
+    }
+
+    #[wasm_bindgen(setter = "nonce")]
+    pub fn set_nonce(&mut self, nonce: IdentityNonce) {
+        self.0.set_nonce(nonce);
+    }
+
+    #[wasm_bindgen(setter = "identityIdentifier")]
+    pub fn set_identity_identifier(&mut self, js_identity_id: &JsValue) -> Result<(), JsValue> {
+        let identity_id = IdentifierWASM::try_from(js_identity_id)?;
+        self.0.set_identity_id(identity_id.clone().into());
+        Ok(())
+    }
+
+    #[wasm_bindgen(setter = "publicKeyIdsToAdd")]
+    pub fn set_public_key_ids_to_add(
+        &mut self,
+        js_add_public_keys: &js_sys::Array,
+    ) -> Result<(), JsValue> {
+        let add_public_keys: Vec<IdentityPublicKeyInCreationWASM> =
+            IdentityPublicKeyInCreationWASM::vec_from_js_value(js_add_public_keys)?;
+
+        let keys: Vec<IdentityPublicKeyInCreation> =
+            add_public_keys.iter().map(|id| id.clone().into()).collect();
+
+        Ok(self.0.set_public_keys_to_add(keys))
+    }
+
+    #[wasm_bindgen(setter = "publicKeyIdsToDisable")]
+    pub fn set_public_key_ids_to_disable(&mut self, public_keys: Vec<KeyID>) {
+        self.0.set_public_key_ids_to_disable(public_keys)
+    }
+
+    #[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)
+    }
+
+    #[wasm_bindgen(getter = "signature")]
+    pub fn get_signature(&self) -> Vec<u8> {
+        self.0.signature().to_vec()
+    }
+
+    #[wasm_bindgen(js_name = "getSignableBytes")]
+    pub fn get_signable_bytes(&self) -> Result<Vec<u8>, JsValue> {
+        self.0.signable_bytes().with_js_error()
+    }
+
+    #[wasm_bindgen(getter = "signaturePublicKeyId")]
+    pub fn get_signature_public_key_id(&self) -> KeyID {
+        self.0.signature_public_key_id()
+    }
+
+    #[wasm_bindgen(setter = "signature")]
+    pub fn set_signature(&mut self, signature: Vec<u8>) {
+        self.0.set_signature_bytes(signature)
+    }
+
+    #[wasm_bindgen(setter = "signaturePublicKeyId")]
+    pub fn set_signature_public_key_id(&mut self, signature_public_key_id: KeyID) {
+        self.0.set_signature_public_key_id(signature_public_key_id)
+    }
+
+    #[wasm_bindgen(js_name = "toBytes")]
+    pub fn to_bytes(&self) -> Result<Vec<u8>, JsValue> {
+        self.0.serialize_to_bytes().with_js_error()
+    }
+
+    #[wasm_bindgen(js_name = "fromBytes")]
+    pub fn from_bytes(bytes: Vec<u8>) -> Result<IdentityUpdateTransitionWASM, JsValue> {
+        let rs_transition =
+            IdentityUpdateTransition::deserialize_from_bytes(bytes.as_slice()).with_js_error()?;
+
+        Ok(IdentityUpdateTransitionWASM(rs_transition))
+    }
+
+    #[wasm_bindgen(js_name = "toStateTransition")]
+    pub fn to_state_transition(&self) -> StateTransitionWASM {
+        StateTransitionWASM::from(StateTransition::from(self.0.clone()))
+    }
+
+    #[wasm_bindgen(js_name = "fromStateTransition")]
+    pub fn from_state_transition(
+        st: StateTransitionWASM,
+    ) -> Result<IdentityUpdateTransitionWASM, JsValue> {
+        let rs_st: StateTransition = st.into();
+
+        match rs_st {
+            StateTransition::IdentityUpdate(st) => Ok(IdentityUpdateTransitionWASM(st)),
+            _ => Err(JsValue::from_str(&"Invalid state transition type)")),
+        }
+    }
+}

package/packages/private_key/Cargo.toml

@@ -7,7 +7,7 @@ edition = "2024"
 crate-type = ["cdylib", "lib"]
 
 [dependencies]
-wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"] }
+wasm-bindgen = { version = "=0.2.100", default-features = false, features = ["serde-serialize"] }
 dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
     "identity-value-conversion",
 ]}

package/packages/state_transition/Cargo.toml

@@ -7,10 +7,11 @@ edition = "2024"
 crate-type = ["cdylib", "lib"]
 
 [dependencies]
-wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"], default-features = false }
+wasm-bindgen = { version = "=0.2.100", default-features = false, features = ["serde-serialize"] }
 pshenmic_dpp_public_key = {path = "../identity_public_key" }
 pshenmic_dpp_private_key = {path = "../private_key"}
 pshenmic_dpp_utils = {path = "../utils"}
+pshenmic_dpp_identifier = {path = "../identifier"}
 pshenmic_dpp_mock_bls = {path = "../mock_bls"}
 pshenmic_dpp_enums = {path = "../enums"}
 dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [

package/packages/state_transition/src/lib.rs

@@ -7,6 +7,7 @@ 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_identifier::IdentifierWASM;
 use pshenmic_dpp_mock_bls::MockBLS;
 use pshenmic_dpp_private_key::PrivateKeyWASM;
 use pshenmic_dpp_public_key::IdentityPublicKeyWASM;
@@ -111,8 +112,8 @@ impl StateTransitionWASM {
     }
 
     #[wasm_bindgen(js_name = "getOwnerId")]
-    pub fn get_owner_id(&self) -> Vec<u8> {
-        self.0.owner_id().to_vec()
+    pub fn get_owner_id(&self) -> IdentifierWASM {
+        self.0.owner_id().into()
     }
 
     #[wasm_bindgen(getter = "signature")]

package/packages/utils/Cargo.toml

@@ -7,12 +7,12 @@ edition = "2024"
 crate-type = ["cdylib", "lib"]
 
 [dependencies]
-wasm-bindgen = { version = "=0.2.100", features = ["serde-serialize"] }
+wasm-bindgen = { version = "=0.2.100", default-features = false, features = ["serde-serialize"] }
 anyhow = { version = "1.0.75" }
 dpp = { git = "https://github.com/dashpay/platform", branch = "master", features = [
     "platform-value",
     "document-json-conversion"
-]}
+] }
 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" }

package/packages/utils/src/lib.rs

@@ -221,9 +221,6 @@ pub fn get_bool_from_options(
     }
 }
 
-#[allow(dead_code)]
-#[deprecated(note = "This function is marked as unused.")]
-#[allow(deprecated)]
 pub fn get_class_name(value: &JsValue) -> String {
     js_sys::Object::get_prototype_of(value)
         .constructor()

package/scripts/build-js.sh

@@ -6,11 +6,18 @@ DIST_WASM_DIR="$DIST_DIR/wasm"
 DIST_WASM_BINARY_BASE_64="$DIST_WASM_DIR/pshenmic_dpp_bg.js"
 DIST_WASM_BINARY_RAW="$DIST_WASM_DIR/pshenmic_dpp_bg.wasm"
 DIST_WASM_JS="$DIST_WASM_DIR/pshenmic_dpp.js"
+DIST_WASM_TS_BG="$DIST_WASM_DIR/pshenmic_dpp_bg.wasm.d.ts"
+DIST_WASM_TS="$DIST_WASM_DIR/pshenmic_dpp.d.ts"
+DIST_WASM_TS_INDEX="$DIST_WASM_DIR/index.d.ts"
+
 
 ## Paths to wasm files produced by wasm-bindgen
 WASM_DIR="$PWD/wasm"
 WASM_JS_CODE_PATH="$WASM_DIR/pshenmic_dpp.js"
 WASM_BINARY_PATH="$WASM_DIR/pshenmic_dpp_bg.wasm"
+WASM_TS_BG_CODE_PATH="$WASM_DIR/pshenmic_dpp_bg.wasm.d.ts"
+WASM_TS_CODE_PATH="$WASM_DIR/pshenmic_dpp.d.ts"
+WASM_TS_INDEX_CODE_PATH="$PWD/typings/index.d.ts"
 
 # Create directory in dist to save transpiled wasm code and TS typings
 mkdir -p $DIST_WASM_DIR
@@ -20,6 +27,10 @@ rm -rf $DIST_WASM_BINARY_BASE_64
 rm -rf $DIST_WASM_BINARY_RAW
 rm -rf $DIST_WASM_JS
 
+rm -rf $DIST_WASM_TS_INDEX
+rm -rf $DIST_WASM_TS_BG
+rm -rf $DIST_WASM_TS
+
 ## Converting wasm into base64 and saving it to dist folder
 
 if [[ "${RAW}" == "true" ]]; then
@@ -33,6 +44,11 @@ fi
 echo "Copying ES module to dist"
 cp $WASM_JS_CODE_PATH $DIST_WASM_JS
 
+echo "Copying TS types to dist"
+cp $WASM_TS_INDEX_CODE_PATH $DIST_WASM_TS_INDEX
+cp $WASM_TS_BG_CODE_PATH $DIST_WASM_TS_BG
+cp $WASM_TS_CODE_PATH $DIST_WASM_TS
+
 echo "Cleaning wasm build"
 rm -rf $WASM_DIR
 

package/scripts/build.sh

@@ -12,7 +12,8 @@ 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"
+STRIP_COMMAND=" wasm-snip ${PWD}/target/${TARGET}/${PROFILE}/pshenmic_dpp.wasm -o ${PWD}/target/${TARGET}/${PROFILE}/pshenmic_dpp.wasm --snip-rust-fmt-code --snip-rust-panicking-code"
+BINDGEN_COMMAND="wasm-bindgen --typescript --out-dir=${OUTPUT_DIR} --target=web --omit-default-module-path ${PWD}/target/${TARGET}/${PROFILE}/pshenmic_dpp.wasm"
 
 if ! [[ -d ${OUTPUT_DIR} ]]; then
   mkdir -p "${OUTPUT_DIR}"
@@ -25,6 +26,7 @@ if [[ "${OSTYPE}" == "darwin"* ]]; then
   AR=${AR_PATH} CC=${CLANG_PATH} ${BINDGEN_COMMAND}
 else
   ${BUILD_COMMAND}
+  ${STRIP_COMMAND}
   ${BINDGEN_COMMAND}
 fi
 
@@ -32,6 +34,8 @@ if command -v wasm-opt &> /dev/null; then
   echo "Optimizing wasm using Binaryen"
   wasm-opt \
     --generate-global-effects \
+    --enable-bulk-memory \
+    --enable-nontrapping-float-to-int  \
     -Oz \
     -tnh \
     --flatten \

package/src/lib.rs

@@ -12,6 +12,7 @@ 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_identifier;
 pub use pshenmic_dpp_identity;
 pub use pshenmic_dpp_identity_transitions;
 pub use pshenmic_dpp_state_transition;

package/tests/AssetLockProof.spec.js

@@ -0,0 +1,80 @@
+const assert = require('assert')
+const { describe, it, before } = require('mocha')
+const initWasm = require('./utils/wasm')
+const { instantLockBytes, transactionBytes } = require('./mocks/Locks')
+
+let wasm
+
+describe('AssetLockProof', function () {
+  before(async function () {
+    wasm = initWasm()
+  })
+
+  describe('serialization / deserialization', function () {
+    it('should allow to get instant lock proof via constructor', () => {
+      const instantLockProof = new wasm.AssetLockProofWASM('instant')
+
+      assert.equal(instantLockProof.constructor.name, 'AssetLockProofWASM')
+    })
+
+    it('shouldn\'t allow to get chain lock proof via constructor', () => {
+      try {
+        new wasm.AssetLockProofWASM('chain')
+      } catch (e) {
+        assert.ok(true)
+        return
+      }
+      assert.ok()
+    })
+
+    it('should allow to create instant lock proof from values', () => {
+      const instantLockProof = wasm.AssetLockProofWASM.createInstantAssetLockProof(instantLockBytes, transactionBytes, 0)
+
+      assert.equal(instantLockProof.constructor.name, 'AssetLockProofWASM')
+    })
+
+    it('should allow to create chain lock proof from values', () => {
+      const outpoint = new wasm.OutPointWASM('e8b43025641eea4fd21190f01bd870ef90f1a8b199d8fc3376c5b62c0b1a179d', 1)
+
+      const chainLockProof = wasm.AssetLockProofWASM.createChainAssetLockProof(1, outpoint)
+
+      assert.equal(chainLockProof.constructor.name, 'AssetLockProofWASM')
+    })
+  })
+
+  describe('getters', function () {
+    it('should allow to get lock type', () => {
+      const outpoint = new wasm.OutPointWASM('e8b43025641eea4fd21190f01bd870ef90f1a8b199d8fc3376c5b62c0b1a179d', 1)
+
+      const chainLockProof = wasm.AssetLockProofWASM.createChainAssetLockProof(1, outpoint)
+
+      const instantLockProof = new wasm.AssetLockProofWASM('instant')
+
+      assert.equal(chainLockProof.getLockType(), 'Chain')
+      assert.equal(instantLockProof.getLockType(), 'Instant')
+    })
+
+    it('should allow to get lock instances', () => {
+      const outpoint = new wasm.OutPointWASM('e8b43025641eea4fd21190f01bd870ef90f1a8b199d8fc3376c5b62c0b1a179d', 1)
+
+      const chainLockProof = wasm.AssetLockProofWASM.createChainAssetLockProof(1, outpoint)
+
+      const instantLockProof = new wasm.AssetLockProofWASM('instant')
+
+      assert.equal(chainLockProof.getChainLockProof().constructor.name, 'ChainAssetLockProofWASM')
+      assert.equal(instantLockProof.getInstantLockProof().constructor.name, 'InstantAssetLockProofWASM')
+    })
+
+    it('should allow to return object of lock', () => {
+      const instantLockProof = new wasm.AssetLockProofWASM('instant')
+
+      const expected = {
+        instantLock: [1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+        transaction: [0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 255, 255, 255, 255, 0, 255, 255, 255, 255, 1, 255, 255, 255, 255, 255, 255, 255, 255, 0, 0, 0, 0, 0],
+        outputIndex: 0
+      }
+
+      assert.deepEqual(instantLockProof.toObject(), expected)
+    })
+  })
+})

package/tests/ChainLockProof.spec.js

@@ -0,0 +1,69 @@
+const assert = require('assert')
+const { describe, it, before } = require('mocha')
+const initWasm = require('./utils/wasm')
+
+let wasm
+
+describe('InstantLock', function () {
+  before(async function () {
+    wasm = initWasm()
+  })
+
+  describe('serialization / deserialization', function () {
+    it('should allow to create chain lock proof from values', () => {
+      const outpoint = new wasm.OutPointWASM('e8b43025641eea4fd21190f01bd870ef90f1a8b199d8fc3376c5b62c0b1a179d', 1)
+      const chainlock = new wasm.ChainAssetLockProofWASM(11, outpoint)
+
+      assert.notEqual(chainlock.__wbg_ptr, 0)
+    })
+
+    it('should allow to create chain lock proof from object', () => {
+      const outpoint = new wasm.OutPointWASM('e8b43025641eea4fd21190f01bd870ef90f1a8b199d8fc3376c5b62c0b1a179d', 1)
+      const chainlock = wasm.ChainAssetLockProofWASM.fromRawObject({
+        coreChainLockedHeight: 11,
+        outPoint: Array.from(outpoint.toBytes())
+      })
+
+      assert.notEqual(chainlock.__wbg_ptr, 0)
+    })
+  })
+
+  describe('getters', function () {
+    it('should allow to get coreChainLockedHeight', () => {
+      const outpoint = new wasm.OutPointWASM('e8b43025641eea4fd21190f01bd870ef90f1a8b199d8fc3376c5b62c0b1a179d', 1)
+      const chainlock = new wasm.ChainAssetLockProofWASM(11, outpoint)
+
+      assert.equal(chainlock.coreChainLockedHeight, 11)
+    })
+
+    it('should allow to get outPoint', () => {
+      const outpoint = new wasm.OutPointWASM('e8b43025641eea4fd21190f01bd870ef90f1a8b199d8fc3376c5b62c0b1a179d', 1)
+      const chainlock = new wasm.ChainAssetLockProofWASM(11, outpoint)
+
+      assert.equal(chainlock.outPoint.constructor.name, 'OutPointWASM')
+    })
+  })
+
+  describe('setters', function () {
+    it('should allow to set coreChainLockedHeight', () => {
+      const outpoint = new wasm.OutPointWASM('e8b43025641eea4fd21190f01bd870ef90f1a8b199d8fc3376c5b62c0b1a179d', 1)
+      const chainlock = new wasm.ChainAssetLockProofWASM(11, outpoint)
+
+      chainlock.coreChainLockedHeight = 33
+
+      assert.equal(chainlock.coreChainLockedHeight, 33)
+    })
+
+    it('should allow to get outPoint', () => {
+      const outpoint = new wasm.OutPointWASM('e8b43025641eea4fd21190f01bd870ef90f1a8b199d8fc3376c5b62c0b1a179d', 1)
+      const chainlock = new wasm.ChainAssetLockProofWASM(11, outpoint)
+
+      const newOutpoint = new wasm.OutPointWASM('e8b43025641eea4fd21190f01bd870ef90f1a8b199d8fc3376c5b62c0b1a179d', 222)
+
+      chainlock.outPoint = newOutpoint
+
+      assert.equal(chainlock.outPoint.getVOUT(), 222)
+      assert.notEqual(newOutpoint.__wbg_ptr, 0)
+    })
+  })
+})