pshenmic-dpp 1.0.4 → 1.0.6

package/packages/state_transition/src/lib.rs

@@ -1,11 +1,18 @@
-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_identifier::IdentifierWASM;
 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;
 
@@ -27,65 +34,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.clone().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))),
-        }
+    ) -> 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 {
+        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().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());
 
@@ -94,4 +91,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) -> IdentifierWASM {
+        self.0.owner_id().into()
+    }
+
+    #[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,20 +1,19 @@
 [package]
 name = "pshenmic_dpp_utils"
-version = "0.1.0"
+version.workspace = true
 edition = "2024"
 
 [lib]
 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" }
 serde = { version = "1.0.197", features = ["derive"] }
-itertools = { version = "0.13" }

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;
@@ -222,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()
@@ -274,7 +270,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 +278,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 +321,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

@@ -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
@@ -27,13 +38,19 @@ if [[ "${RAW}" == "true" ]]; then
 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 "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
+rm -rf $WASM_DIR
+
+echo "Total build size: "
+du -sh $DIST_WASM_DIR

package/scripts/build.sh

@@ -9,8 +9,11 @@ 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"
+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}"
@@ -23,12 +26,34 @@ if [[ "${OSTYPE}" == "darwin"* ]]; then
   AR=${AR_PATH} CC=${CLANG_PATH} ${BINDGEN_COMMAND}
 else
   ${BUILD_COMMAND}
+  ${STRIP_COMMAND}
   ${BINDGEN_COMMAND}
 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 \
+    --enable-bulk-memory \
+    --enable-nontrapping-float-to-int  \
+    -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,11 +1,18 @@
 #![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_data_contract_transitions;
-pub use pshenmic_dpp_document_batch;
 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)
+    })
+  })
+})

package/tests/CoreScript.spec.js

@@ -0,0 +1,37 @@
+const assert = require('assert')
+const { describe, it, before } = require('mocha')
+const initWasm = require('./utils/wasm')
+
+let wasm
+
+describe('CoreScript', function () {
+  before(async function () {
+    wasm = initWasm()
+  })
+
+  describe('serialization / deserialization', function () {
+    it('should allow to create from bytes', () => {
+      const script = wasm.CoreScriptWASM.fromBytes(Buffer.from('76a914c3dbfd40e7f8a4845c2f8e868a167c984049764988ac', 'hex'))
+
+      assert.notEqual(script._wbg_ptr, 0)
+    })
+
+    it('should allow to create P2PKH', () => {
+      const script = wasm.CoreScriptWASM.newP2PKH([195, 219, 253, 64, 231, 248, 164, 132, 92, 47, 142, 134, 138, 22, 124, 152, 64, 73, 118, 73])
+
+      assert.notEqual(script._wbg_ptr, 0)
+    })
+
+    it('should allow to create P2SH', () => {
+      const script = wasm.CoreScriptWASM.newP2SH([195, 219, 253, 64, 231, 248, 164, 132, 92, 47, 142, 134, 138, 22, 124, 152, 64, 73, 118, 73])
+
+      assert.notEqual(script._wbg_ptr, 0)
+    })
+
+    it('should allow to convert to asm P2PKH', () => {
+      const script = wasm.CoreScriptWASM.newP2PKH([195, 219, 253, 64, 231, 248, 164, 132, 92, 47, 142, 134, 138, 22, 124, 152, 64, 73, 118, 73])
+
+      assert.equal(script.toASMString(), 'OP_DUP OP_HASH160 OP_PUSHBYTES_20 c3dbfd40e7f8a4845c2f8e868a167c9840497649 OP_EQUALVERIFY OP_CHECKSIG')
+    })
+  })
+})