pshenmic-dpp 1.0.5 → 1.0.6

package/docs/PrefundedVotingBalance.md

@@ -0,0 +1,48 @@
+# PrefundedVotingBalanceWASM
+
+This class allows to create PrefundedVotingBalance instance and interact.
+
+`PrefundedVotingBalanceWASM` can be created only via constructor
+
+Constructor arguments: 
+- `indexName -> String`
+- `credits -> BigInt`
+
+___
+## Navigation
+
+- [Example](#example)
+- [Fields](#fields)
+  - [indexName](#indexname)
+  - [credits](#credits)
+___
+## Example
+
+```js
+new PrefundedVotingBalanceWASM('value', BigInt(9999))
+```
+
+___
+
+## Fields
+All fields only readable.
+
+### `indexName`
+Contains index name with value for voting in `String`
+
+```js
+const prefundedVotingBalance = new PrefundedVotingBalanceWASM('value', BigInt(9999))
+
+prefundedVotingBalance.indexName // -> String
+```
+
+___
+
+### `credits`
+Contains amount of credits for voting in `BigInt`
+
+```js
+const prefundedVotingBalance = new PrefundedVotingBalanceWASM('value', BigInt(9999))
+
+prefundedVotingBalance.credits // -> BigInt
+```

package/docs/PrivateKey.md

@@ -0,0 +1,112 @@
+# PrivateKeyWASM
+
+This class allows to create PrivateKey instance
+
+___
+
+## Navigation
+
+- [Example](#example)
+- [Static methods](#static-mehtods)
+    - [fromWIF](#fromwif)
+    - [fromBytes](#frombytes)
+    - [fromHex](#fromhex)
+- [Getters methods](#getters-methods)
+    - [getWIF](#getwif)
+    - [getBytes](#getbytes)
+    - [getHex](#gethex)
+    - [getPublicKeyHash](#getpublickeyhash)
+
+___
+
+## Example
+
+```js
+const pkey = PrivateKeyWASM.fromWIF('cR4EZ2nAvCmn2cFepKn7UgSSQFgFTjkySAchvcoiEVdm48eWjQGn')
+```
+
+___
+
+## Static mehtods
+
+### `fromWIF`
+
+Allows to create `PrivateKeyWASM` from WIF `String`
+
+```js
+PrivateKeyWASM.fromWIF('cR4EZ2nAvCmn2cFepKn7UgSSQFgFTjkySAchvcoiEVdm48eWjQGn')
+```
+
+___
+
+### `fromBytes`
+
+Allows to create `PrivateKey` from bytes in `ArrayLike`
+
+```js
+const bytes = [103, 173, 22, 105, 216, 130, 218, 37, 107, 111, 160, 94, 27, 10, 227, 132, 166, 172, 138, 237, 20, 110, 165, 54, 2, 184, 255, 14, 30, 156, 24, 233]
+
+PrivateKeyWASM.fromBytes(bytes, 'Mainnet')
+```
+
+___
+
+### `fromHex`
+
+Allows to create `PrivateKey` from bytes in Hex `String`
+
+```js
+const hex = '67ad1669d882da256b6fa05e1b0ae384a6ac8aed146ea53602b8ff0e1e9c18e9'
+
+PrivateKeyWASM.fromHex(hex, 'Mainnet')
+```
+
+___
+
+## Getters methods
+
+### `getWIF`
+
+Allows to return PrivateKey WIF in `String`
+
+```js
+const key = PrivateKeyWASM.fromWIF('cR4EZ2nAvCmn2cFepKn7UgSSQFgFTjkySAchvcoiEVdm48eWjQGn')
+
+key.getWIF() // -> WIF String
+```
+
+___
+
+### `getBytes`
+
+Allows to return PrivateKey bytes in `ArrayLike`
+
+```js
+const key = PrivateKeyWASM.fromWIF('cR4EZ2nAvCmn2cFepKn7UgSSQFgFTjkySAchvcoiEVdm48eWjQGn')
+
+key.getBytes() // -> ArrayLike
+```
+
+___
+
+### `getHex`
+
+Allows to return PrivateKey bytes in hex `String`
+
+```js
+const key = PrivateKeyWASM.fromWIF('cR4EZ2nAvCmn2cFepKn7UgSSQFgFTjkySAchvcoiEVdm48eWjQGn')
+
+key.getHex() // -> String
+```
+
+___
+
+### `getPublicKeyHash`
+
+Allows to return PublicKey hash from PrivateKey in `String`
+
+```js
+const key = PrivateKeyWASM.fromWIF('cR4EZ2nAvCmn2cFepKn7UgSSQFgFTjkySAchvcoiEVdm48eWjQGn')
+
+key.getPublicKeyHash() // -> String
+```

package/docs/TxOut.md

@@ -0,0 +1,93 @@
+# TxOutWASM
+
+This class allows to create and interact with TxOut struct
+
+`TxOutWASM` can be created only via constructor
+
+Constructor arguments:
+
+- `value -> BigInt`
+- `scriptPublicKey -> String | ArrayLike`
+
+___
+
+## Navigation
+
+- [Example](#Example)
+- [Fields](#fields)
+    - [value](#value)
+    - [scriptPubKeyHex](#scriptpubkeyhex)
+    - [scriptPubKeyBytes](#scriptpubkeybytes)
+- [Static](#static)
+    - [getScriptPubKeyASM](#getscriptpubkeyasm)
+
+___
+
+### Example
+
+```js
+const out = new TxOutWASM(
+  BigInt(100),
+  '76a9141a486a3855e6dc6dd02874424f53a6f2197b3d4588ac'
+)
+```
+
+___
+
+## Fields
+
+All fields are readable and writable.
+
+### `value`
+
+Allows to read and write value of TxOut in `BigInt`
+
+```js
+const out = new TxOutWASM(BigInt(100), '76a9141a486a3855e6dc6dd02874424f53a6f2197b3d4588ac')
+
+out.value = BigInt(101)
+
+out.value // -> BigInt
+```
+
+___
+
+### `scriptPubKeyHex`
+
+Allows to get script public key in HEX `String`
+
+```js
+const out = new TxOutWASM(BigInt(100), '76a9141a486a3855e6dc6dd02874424f53a6f2197b3d4588ac')
+
+out.scriptPubKeyHex = '76a9141a486a3855e6dc6dd02874424f53a6f2197b3d4588ac'
+
+out.scriptPubKeyHex // -> String
+```
+
+___
+
+### `scriptPubKeyBytes`
+
+Same as [scriptPubKeyHex](#scriptpubkeyhex) but in bytes
+
+```js
+const out = new TxOutWASM(BigInt(100), '76a9141a486a3855e6dc6dd02874424f53a6f2197b3d4588ac')
+
+out.scriptPubKeyBytes = []
+
+out.scriptPubKeyBytes // -> Uint8Array
+```
+
+___
+
+## Static
+
+### `getScriptPubKeyASM`
+
+Allows to get script in ASM `String`
+
+```js
+const out = new TxOutWASM(BigInt(100), '76a9141a486a3855e6dc6dd02874424f53a6f2197b3d4588ac')
+
+out.getScriptPubKeyASM() // -> String
+```

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "pshenmic-dpp",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "main": "dist/wasm/pshenmic_dpp.js",
+  "types": "dist/wasm/index.d.ts",
   "repository": {
     "type": "git",
     "url": "https://github.com/owl352/pshenmic-dpp"
@@ -27,6 +28,5 @@
     "core-js": "^3.41.0",
     "mocha": "^11.1.0",
     "standard": "^17.1.2"
-  },
-  "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
+  }
 }

package/packages/asset_lock_proof/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "pshenmic_dpp_asset_lock_proof"
+version.workspace = true
+edition = "2024"
+
+[lib]
+crate-type = ["cdylib", "lib"]
+
+[dependencies]
+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 = [
+    "state-transition-signing"
+]}
+pshenmic_dpp_utils = {path = "../utils"}
+pshenmic_dpp_enums = {path = "../enums"}
+js-sys = "0.3.53"
+web-sys = {version = "0.3.77", features = ["console"]}
+serde-wasm-bindgen = { git = "https://github.com/QuantumExplorer/serde-wasm-bindgen", branch = "feat/not_human_readable" }
+serde = { version = "1.0.197", features = ["derive"] }

package/packages/asset_lock_proof/src/chain/mod.rs

@@ -0,0 +1,79 @@
+use crate::outpoint::OutPointWASM;
+use dpp::identity::state_transition::asset_lock_proof::chain::ChainAssetLockProof;
+use serde::Deserialize;
+use wasm_bindgen::prelude::wasm_bindgen;
+use wasm_bindgen::{JsError, JsValue};
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct ChainAssetLockProofParams {
+    core_chain_locked_height: u32,
+    out_point: Vec<u8>,
+}
+
+#[wasm_bindgen(js_name = "ChainAssetLockProofWASM")]
+pub struct ChainAssetLockProofWASM(ChainAssetLockProof);
+
+impl From<ChainAssetLockProofWASM> for ChainAssetLockProof {
+    fn from(chain_lock: ChainAssetLockProofWASM) -> Self {
+        chain_lock.0
+    }
+}
+
+impl From<ChainAssetLockProof> for ChainAssetLockProofWASM {
+    fn from(chain_lock: ChainAssetLockProof) -> Self {
+        ChainAssetLockProofWASM(chain_lock)
+    }
+}
+
+#[wasm_bindgen]
+impl ChainAssetLockProofWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        core_chain_locked_height: u32,
+        out_point: &OutPointWASM,
+    ) -> Result<ChainAssetLockProofWASM, JsValue> {
+        Ok(ChainAssetLockProofWASM(ChainAssetLockProof {
+            core_chain_locked_height,
+            out_point: out_point.clone().into(),
+        }))
+    }
+
+    #[wasm_bindgen(js_name = "fromRawObject")]
+    pub fn from_raw_value(
+        raw_asset_lock_proof: JsValue,
+    ) -> Result<ChainAssetLockProofWASM, JsValue> {
+        let parameters: ChainAssetLockProofParams =
+            serde_wasm_bindgen::from_value(raw_asset_lock_proof)
+                .map_err(|err| JsError::from(err))?;
+
+        let out_point: [u8; 36] = parameters
+            .out_point
+            .try_into()
+            .map_err(|_| JsError::new("outPoint must be a 36 byte array"))?;
+
+        let rs_proof = ChainAssetLockProof::new(parameters.core_chain_locked_height, out_point);
+
+        Ok(ChainAssetLockProofWASM(rs_proof))
+    }
+
+    #[wasm_bindgen(setter = "coreChainLockedHeight")]
+    pub fn set_core_chain_locked_height(&mut self, core_chain_locked_height: u32) {
+        self.0.core_chain_locked_height = core_chain_locked_height;
+    }
+
+    #[wasm_bindgen(setter = "outPoint")]
+    pub fn set_out_point(&mut self, outpoint: &OutPointWASM) {
+        self.0.out_point = outpoint.clone().into();
+    }
+
+    #[wasm_bindgen(getter = "coreChainLockedHeight")]
+    pub fn get_core_chain_locked_height(self) -> u32 {
+        self.0.core_chain_locked_height
+    }
+
+    #[wasm_bindgen(getter = "outPoint")]
+    pub fn get_out_point(self) -> OutPointWASM {
+        self.0.out_point.into()
+    }
+}

package/packages/asset_lock_proof/src/instant/instant_lock.rs

@@ -0,0 +1,111 @@
+use crate::outpoint::OutPointWASM;
+use dpp::dashcore::bls_sig_utils::BLSSignature;
+use dpp::dashcore::hash_types::CycleHash;
+use dpp::dashcore::hashes::hex::FromHex;
+use dpp::dashcore::secp256k1::hashes::hex::Case::Lower;
+use dpp::dashcore::secp256k1::hashes::hex::DisplayHex;
+use dpp::dashcore::{InstantLock, Txid};
+use std::str::FromStr;
+use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name = "InstantLockWASM")]
+#[derive(Clone)]
+pub struct InstantLockWASM(InstantLock);
+
+impl From<InstantLockWASM> for InstantLock {
+    fn from(value: InstantLockWASM) -> Self {
+        value.0
+    }
+}
+
+impl From<InstantLock> for InstantLockWASM {
+    fn from(value: InstantLock) -> Self {
+        InstantLockWASM(value)
+    }
+}
+
+#[wasm_bindgen]
+impl InstantLockWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        version: u8,
+        js_inputs: &js_sys::Array,
+        txid: String,
+        cycle_hash: String,
+        bls_signature: String,
+    ) -> Result<InstantLockWASM, JsValue> {
+        let inputs = OutPointWASM::vec_from_js_value(js_inputs)?;
+
+        Ok(InstantLockWASM(InstantLock {
+            version,
+            inputs: inputs.iter().map(|input| input.clone().into()).collect(),
+            txid: Txid::from_hex(&txid).map_err(|err| JsValue::from(err.to_string()))?,
+            cyclehash: CycleHash::from_str(&cycle_hash)
+                .map_err(|err| JsValue::from(err.to_string()))?,
+            signature: BLSSignature::from_hex(&bls_signature)
+                .map_err(|err| JsValue::from(err.to_string()))?,
+        }))
+    }
+
+    #[wasm_bindgen(getter = "version")]
+    pub fn get_version(&self) -> u8 {
+        self.0.version
+    }
+
+    #[wasm_bindgen(getter = "inputs")]
+    pub fn get_inputs(&self) -> Vec<OutPointWASM> {
+        self.0
+            .inputs
+            .iter()
+            .map(|input| input.clone().into())
+            .collect()
+    }
+
+    #[wasm_bindgen(getter = "txid")]
+    pub fn get_txid(&self) -> String {
+        self.0.txid.to_hex()
+    }
+
+    #[wasm_bindgen(getter = "cyclehash")]
+    pub fn get_cycle_hash(&self) -> String {
+        self.0.cyclehash.to_string()
+    }
+
+    #[wasm_bindgen(getter = "blsSignature")]
+    pub fn get_bls_signature(&self) -> String {
+        self.0.signature.to_bytes().to_hex_string(Lower)
+    }
+
+    #[wasm_bindgen(setter = "version")]
+    pub fn set_version(&mut self, v: u8) {
+        self.0.version = v;
+    }
+
+    #[wasm_bindgen(setter = "inputs")]
+    pub fn set_inputs(&mut self, inputs: &js_sys::Array) -> Result<(), JsValue> {
+        let inputs = OutPointWASM::vec_from_js_value(inputs)?;
+        self.0.inputs = inputs.iter().map(|input| input.clone().into()).collect();
+        Ok(())
+    }
+
+    #[wasm_bindgen(setter = "txid")]
+    pub fn set_txid(&mut self, txid: String) -> Result<(), JsValue> {
+        self.0.txid = Txid::from_hex(&txid).map_err(|err| JsValue::from(err.to_string()))?;
+        Ok(())
+    }
+
+    #[wasm_bindgen(setter = "cyclehash")]
+    pub fn set_cycle_hash(&mut self, cycle_hash: String) -> Result<(), JsValue> {
+        self.0.cyclehash =
+            CycleHash::from_str(&cycle_hash).map_err(|err| JsValue::from(err.to_string()))?;
+        Ok(())
+    }
+
+    #[wasm_bindgen(setter = "blsSignature")]
+    pub fn set_bls_signature(&mut self, bls_signature: String) -> Result<(), JsValue> {
+        self.0.signature =
+            BLSSignature::from_hex(&bls_signature).map_err(|err| JsValue::from(err.to_string()))?;
+        Ok(())
+    }
+}

package/packages/asset_lock_proof/src/instant/mod.rs

@@ -0,0 +1,115 @@
+mod instant_lock;
+
+use crate::instant::instant_lock::InstantLockWASM;
+use crate::outpoint::OutPointWASM;
+use crate::tx_out::TxOutWASM;
+use dpp::dashcore::consensus::deserialize;
+use dpp::dashcore::{InstantLock, Transaction};
+use dpp::identity::state_transition::asset_lock_proof::InstantAssetLockProof;
+use pshenmic_dpp_utils::WithJsError;
+use serde::{Deserialize, Serialize};
+use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[derive(Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct InstantAssetLockProofRAW {
+    instant_lock: Vec<u8>,
+    transaction: Vec<u8>,
+    output_index: u32,
+}
+
+#[wasm_bindgen(js_name = "InstantAssetLockProofWASM")]
+pub struct InstantAssetLockProofWASM(InstantAssetLockProof);
+
+impl From<InstantAssetLockProofWASM> for InstantAssetLockProof {
+    fn from(proof: InstantAssetLockProofWASM) -> Self {
+        proof.0
+    }
+}
+
+impl From<InstantAssetLockProof> for InstantAssetLockProofWASM {
+    fn from(proof: InstantAssetLockProof) -> Self {
+        InstantAssetLockProofWASM(proof)
+    }
+}
+
+#[wasm_bindgen]
+impl InstantAssetLockProofWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        instant_lock: Vec<u8>,
+        transaction: Vec<u8>,
+        output_index: u32,
+    ) -> Result<InstantAssetLockProofWASM, JsValue> {
+        let instant_lock: InstantLock =
+            deserialize(instant_lock.as_slice()).map_err(|err| JsValue::from(err.to_string()))?;
+        let transaction: Transaction =
+            deserialize(transaction.as_slice()).map_err(|err| JsValue::from(err.to_string()))?;
+
+        Ok(InstantAssetLockProofWASM(InstantAssetLockProof {
+            instant_lock,
+            transaction,
+            output_index,
+        }))
+    }
+
+    #[wasm_bindgen(js_name = "fromObject")]
+    pub fn from_object(value: JsValue) -> Result<InstantAssetLockProofWASM, JsValue> {
+        let parameters: InstantAssetLockProofRAW =
+            serde_wasm_bindgen::from_value(value).map_err(|err| JsValue::from(err.to_string()))?;
+
+        InstantAssetLockProofWASM::new(
+            parameters.instant_lock,
+            parameters.transaction,
+            parameters.output_index,
+        )
+    }
+
+    #[wasm_bindgen(js_name = "toObject")]
+    pub fn to_object(&self) -> Result<JsValue, JsValue> {
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+
+        self.0
+            .to_object()
+            .with_js_error()?
+            .serialize(&serializer)
+            .map_err(JsValue::from)
+    }
+
+    #[wasm_bindgen(js_name = "getOutput")]
+    pub fn get_output(&self) -> Option<TxOutWASM> {
+        match self.0.output() {
+            Some(output) => Some(output.clone().into()),
+            None => None,
+        }
+    }
+
+    #[wasm_bindgen(js_name = "getOutPoint")]
+    pub fn get_out_point(&self) -> Option<OutPointWASM> {
+        match self.0.out_point() {
+            Some(output) => Some(output.clone().into()),
+            None => None,
+        }
+    }
+
+    #[wasm_bindgen(getter = "outputIndex")]
+    pub fn get_output_index(&self) -> u32 {
+        self.0.output_index()
+    }
+
+    #[wasm_bindgen(getter = "instantLock")]
+    pub fn get_instant_lock(&self) -> InstantLockWASM {
+        self.0.instant_lock.clone().into()
+    }
+
+    #[wasm_bindgen(setter = "outputIndex")]
+    pub fn set_output_index(&mut self, output_index: u32) {
+        self.0.output_index = output_index;
+    }
+
+    #[wasm_bindgen(setter = "instantLock")]
+    pub fn set_instant_lock(&mut self, instant_lock: &InstantLockWASM) {
+        self.0.instant_lock = instant_lock.clone().into();
+    }
+}