pshenmic-dpp 1.0.4 → 1.0.6

package/packages/asset_lock_proof/src/lib.rs

@@ -0,0 +1,133 @@
+pub mod chain;
+pub mod instant;
+pub mod outpoint;
+mod tx_out;
+
+use crate::chain::ChainAssetLockProofWASM;
+use crate::instant::InstantAssetLockProofWASM;
+use dpp::identity::state_transition::asset_lock_proof::InstantAssetLockProof;
+
+use crate::outpoint::OutPointWASM;
+use dpp::prelude::AssetLockProof;
+use pshenmic_dpp_enums::lock_types::AssetLockProofTypeWASM;
+use pshenmic_dpp_utils::WithJsError;
+use serde::Serialize;
+use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name = "AssetLockProofWASM")]
+#[derive(Clone)]
+pub struct AssetLockProofWASM(AssetLockProof);
+
+impl From<AssetLockProofWASM> for AssetLockProof {
+    fn from(proof: AssetLockProofWASM) -> Self {
+        proof.0
+    }
+}
+
+impl From<AssetLockProof> for AssetLockProofWASM {
+    fn from(proof: AssetLockProof) -> Self {
+        AssetLockProofWASM(proof)
+    }
+}
+
+impl From<ChainAssetLockProofWASM> for AssetLockProofWASM {
+    fn from(proof: ChainAssetLockProofWASM) -> Self {
+        AssetLockProofWASM(AssetLockProof::Chain(proof.into()))
+    }
+}
+
+impl From<InstantAssetLockProofWASM> for AssetLockProofWASM {
+    fn from(proof: InstantAssetLockProofWASM) -> Self {
+        AssetLockProofWASM(AssetLockProof::Instant(proof.into()))
+    }
+}
+
+impl From<AssetLockProof> for ChainAssetLockProofWASM {
+    fn from(proof: AssetLockProof) -> ChainAssetLockProofWASM {
+        match proof {
+            AssetLockProof::Chain(chain) => ChainAssetLockProofWASM::from(chain),
+            _ => panic!("invalid asset lock proof. must contains chain lock"),
+        }
+    }
+}
+
+impl From<AssetLockProof> for InstantAssetLockProofWASM {
+    fn from(proof: AssetLockProof) -> InstantAssetLockProofWASM {
+        match proof {
+            AssetLockProof::Instant(instant) => InstantAssetLockProofWASM::from(instant),
+            _ => panic!("invalid asset lock proof. must contains chain lock"),
+        }
+    }
+}
+
+#[wasm_bindgen]
+impl AssetLockProofWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(js_asset_lock_proof_type: JsValue) -> Result<AssetLockProofWASM, JsValue> {
+        let asset_lock_proof_type = AssetLockProofTypeWASM::try_from(js_asset_lock_proof_type)?;
+
+        match asset_lock_proof_type {
+            AssetLockProofTypeWASM::Chain => Err(JsValue::from_str(&"ChainLock unavailable")),
+            AssetLockProofTypeWASM::Instant => {
+                Ok(InstantAssetLockProofWASM::from(InstantAssetLockProof::default()).into())
+            }
+        }
+    }
+
+    #[wasm_bindgen(js_name = "createInstantAssetLockProof")]
+    pub fn new_instant_asset_lock_proof(
+        instant_lock: Vec<u8>,
+        transaction: Vec<u8>,
+        output_index: u32,
+    ) -> Result<AssetLockProofWASM, JsValue> {
+        Ok(InstantAssetLockProofWASM::new(instant_lock, transaction, output_index)?.into())
+    }
+
+    #[wasm_bindgen(js_name = "createChainAssetLockProof")]
+    pub fn new_chain_asset_lock_proof(
+        core_chain_locked_height: u32,
+        out_point: &OutPointWASM,
+    ) -> Result<AssetLockProofWASM, JsValue> {
+        Ok(ChainAssetLockProofWASM::new(core_chain_locked_height, out_point)?.into())
+    }
+
+    // #[wasm_bindgen(js_name = "fromRawObject")]
+    // pub fn from_raw_object(raw_asset_lock_proof: JsValue) -> Result<AssetLockProofWASM, JsValue> {
+    //     let lock_type = get_type_from_raw_asset_lock_proof(&raw_asset_lock_proof)?;
+    //
+    //     match lock_type {
+    //         AssetLockProofTypeWASM::Instant => {
+    //             Ok(InstantAssetLockProofWASM::from_raw_value(raw_asset_lock_proof)?.into())
+    //         }
+    //         AssetLockProofTypeWASM::Chain => {
+    //             Ok(ChainAssetLockProofWASM::from_raw_value(raw_asset_lock_proof)?.into())
+    //         }
+    //     }
+    // }
+
+    #[wasm_bindgen(js_name = "getLockType")]
+    pub fn get_lock_type(&self) -> String {
+        match self.0 {
+            AssetLockProof::Chain(_) => AssetLockProofTypeWASM::Chain.into(),
+            AssetLockProof::Instant(_) => AssetLockProofTypeWASM::Instant.into(),
+        }
+    }
+
+    #[wasm_bindgen(js_name = "getInstantLockProof")]
+    pub fn get_instant_lock(&self) -> InstantAssetLockProofWASM {
+        self.clone().0.into()
+    }
+
+    #[wasm_bindgen(js_name = "getChainLockProof")]
+    pub fn get_chain_lock(&self) -> ChainAssetLockProofWASM {
+        self.clone().0.into()
+    }
+
+    #[wasm_bindgen(js_name = "toObject")]
+    pub fn to_object(&self) -> Result<JsValue, JsValue> {
+        let json_value = self.0.to_raw_object().with_js_error()?;
+
+        Ok(json_value.serialize(&serde_wasm_bindgen::Serializer::json_compatible())?)
+    }
+}

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

@@ -0,0 +1,79 @@
+use dpp::dashcore::{OutPoint, Txid};
+use pshenmic_dpp_utils::IntoWasm;
+use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name = "OutPointWASM")]
+#[derive(Clone)]
+pub struct OutPointWASM(OutPoint);
+
+impl From<OutPoint> for OutPointWASM {
+    fn from(outpoint: OutPoint) -> Self {
+        OutPointWASM(outpoint)
+    }
+}
+
+impl From<OutPointWASM> for OutPoint {
+    fn from(outpoint: OutPointWASM) -> Self {
+        outpoint.0
+    }
+}
+
+impl TryFrom<JsValue> for OutPointWASM {
+    type Error = JsValue;
+    fn try_from(value: JsValue) -> Result<Self, Self::Error> {
+        let value = value.to_wasm::<OutPointWASM>("OutPointWASM")?;
+
+        Ok(value.clone())
+    }
+}
+
+#[wasm_bindgen]
+impl OutPointWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(txid_hex: String, vout: u32) -> Result<OutPointWASM, JsValue> {
+        let out_point = Txid::from_hex(&txid_hex).map_err(|err| JsValue::from(err.to_string()))?;
+
+        Ok(OutPointWASM(OutPoint {
+            txid: out_point,
+            vout,
+        }))
+    }
+
+    #[wasm_bindgen(js_name = "getVOUT")]
+    pub fn get_vout(&self) -> u32 {
+        self.0.vout
+    }
+
+    #[wasm_bindgen(js_name = "getTXID")]
+    pub fn get_tx_id(&self) -> String {
+        self.0.txid.to_hex()
+    }
+
+    #[wasm_bindgen(js_name = "toBytes")]
+    pub fn to_bytes(&self) -> Vec<u8> {
+        let slice: [u8; 36] = self.0.into();
+        slice.to_vec()
+    }
+
+    #[wasm_bindgen(js_name = "fromBytes")]
+    pub fn from_buffer(js_buffer: Vec<u8>) -> OutPointWASM {
+        let mut buffer = [0u8; 36];
+        let bytes = js_buffer.as_slice();
+        let len = bytes.len();
+        buffer[..len].copy_from_slice(bytes);
+
+        OutPointWASM(OutPoint::from(buffer))
+    }
+}
+
+impl OutPointWASM {
+    pub fn vec_from_js_value(js_outpoints: &js_sys::Array) -> Result<Vec<OutPointWASM>, JsValue> {
+        let outpoints: Vec<OutPointWASM> = js_outpoints
+            .iter()
+            .map(|key| OutPointWASM::try_from(key))
+            .collect::<Result<Vec<OutPointWASM>, JsValue>>()?;
+
+        Ok(outpoints)
+    }
+}

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

@@ -0,0 +1,80 @@
+use dpp::dashcore::{ScriptBuf, TxOut};
+use js_sys::Uint8Array;
+use wasm_bindgen::JsValue;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name = "TxOutWASM")]
+#[derive(Clone)]
+pub struct TxOutWASM(TxOut);
+
+impl From<TxOut> for TxOutWASM {
+    fn from(value: TxOut) -> Self {
+        TxOutWASM(value)
+    }
+}
+
+impl From<TxOutWASM> for TxOut {
+    fn from(value: TxOutWASM) -> Self {
+        value.0
+    }
+}
+
+#[wasm_bindgen]
+impl TxOutWASM {
+    #[wasm_bindgen(constructor)]
+    pub fn new(value: u64, script_pubkey: JsValue) -> Result<TxOutWASM, JsValue> {
+        let tx_out: Result<TxOut, JsValue> = match script_pubkey.is_array() {
+            true => Ok(TxOut {
+                value,
+                script_pubkey: ScriptBuf::from_bytes(Uint8Array::from(script_pubkey).to_vec()),
+            }),
+            false => match script_pubkey.is_string() {
+                true => Ok(TxOut {
+                    value,
+                    script_pubkey: ScriptBuf::from_hex(&script_pubkey.as_string().unwrap())
+                        .map_err(|err| JsValue::from(err.to_string()))?,
+                }),
+                false => Err(JsValue::from("Invalid script pubkey")),
+            },
+        };
+
+        Ok(TxOutWASM(tx_out?))
+    }
+
+    #[wasm_bindgen(getter = "value")]
+    pub fn get_value(&self) -> u64 {
+        self.0.value
+    }
+
+    #[wasm_bindgen(getter = "scriptPubKeyHex")]
+    pub fn get_script_pubkey_hex(&self) -> String {
+        self.0.script_pubkey.to_hex_string()
+    }
+
+    #[wasm_bindgen(getter = "scriptPubKeyBytes")]
+    pub fn get_script_pubkey_bytes(&self) -> Vec<u8> {
+        self.0.script_pubkey.to_bytes()
+    }
+
+    #[wasm_bindgen(setter = "value")]
+    pub fn set_value(&mut self, value: u64) {
+        self.0.value = value;
+    }
+
+    #[wasm_bindgen(setter = "scriptPubKeyHex")]
+    pub fn set_script_pubkey_hex(&mut self, script_pubkey_hex: String) -> Result<(), JsValue> {
+        self.0.script_pubkey = ScriptBuf::from_hex(&script_pubkey_hex)
+            .map_err(|err| JsValue::from(err.to_string()))?;
+        Ok(())
+    }
+
+    #[wasm_bindgen(setter = "scriptPubKeyBytes")]
+    pub fn set_script_pubkey_bytes(&mut self, script_pubkey_bytes: Vec<u8>) {
+        self.0.script_pubkey = ScriptBuf::from_bytes(script_pubkey_bytes);
+    }
+
+    #[wasm_bindgen(js_name = "getScriptPubKeyASM")]
+    pub fn get_script_pubkey_asm(&self) -> String {
+        self.0.script_pubkey.to_asm_string()
+    }
+}

package/packages/cbor_conversation/Cargo.toml

@@ -1,13 +1,13 @@
 [package]
 name = "pshenmic_dpp_document_search"
-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"] }
 dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
     "cbor",
 ]}

package/packages/core_script/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "pshenmic_dpp_core_script"
+edition = "2024"
+version.workspace = true
+
+[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"
+]}

package/packages/core_script/src/lib.rs

@@ -0,0 +1,69 @@
+use dpp::dashcore::opcodes;
+use dpp::identity::core_script::CoreScript;
+use dpp::platform_value::string_encoding::Encoding::Base64;
+use wasm_bindgen::prelude::wasm_bindgen;
+
+#[wasm_bindgen(js_name = "CoreScriptWASM")]
+#[derive(Clone)]
+pub struct CoreScriptWASM(CoreScript);
+
+impl From<CoreScriptWASM> for CoreScript {
+    fn from(value: CoreScriptWASM) -> Self {
+        value.0
+    }
+}
+
+impl From<CoreScript> for CoreScriptWASM {
+    fn from(value: CoreScript) -> Self {
+        CoreScriptWASM(value)
+    }
+}
+
+#[wasm_bindgen]
+impl CoreScriptWASM {
+    #[wasm_bindgen(js_name = "fromBytes")]
+    pub fn from_bytes(bytes: Vec<u8>) -> Self {
+        CoreScriptWASM(CoreScript::from_bytes(bytes))
+    }
+
+    #[wasm_bindgen(js_name = "newP2PKH")]
+    pub fn new_p2pkh(js_key_hash: Vec<u8>) -> Self {
+        let mut key_hash = [0u8; 20];
+        let bytes = js_key_hash.as_slice();
+        let len = bytes.len().min(32);
+        key_hash[..len].copy_from_slice(&bytes[..len]);
+
+        CoreScriptWASM(CoreScript::new_p2pkh(key_hash))
+    }
+
+    #[wasm_bindgen(js_name = "newP2SH")]
+    pub fn new_p2sh(js_script_hash: Vec<u8>) -> Self {
+        let mut script_hash = [0u8; 20];
+        let bytes = js_script_hash.as_slice();
+        let len = bytes.len().min(32);
+        script_hash[..len].copy_from_slice(&bytes[..len]);
+
+        let mut bytes = vec![
+            opcodes::all::OP_HASH160.to_u8(),
+            opcodes::all::OP_PUSHBYTES_20.to_u8(),
+        ];
+        bytes.extend_from_slice(&script_hash);
+        bytes.push(opcodes::all::OP_EQUAL.to_u8());
+        Self::from_bytes(bytes)
+    }
+
+    #[wasm_bindgen(js_name = "toString")]
+    pub fn to_string(&self) -> String {
+        self.0.to_string(Base64)
+    }
+
+    #[wasm_bindgen(js_name = "toBytes")]
+    pub fn to_bytes(&self) -> Vec<u8> {
+        self.0.to_bytes()
+    }
+
+    #[wasm_bindgen(js_name = "toASMString")]
+    pub fn to_asm_string(&self) -> String {
+        self.0.to_asm_string()
+    }
+}

package/packages/data_contract/Cargo.toml

@@ -1,17 +1,18 @@
 [package]
 name = "pshenmic_dpp_data_contract"
-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"] }
 pshenmic_dpp_utils = {path = "../utils"}
 pshenmic_dpp_enums = {path = "../enums"}
+pshenmic_dpp_identifier = { path = "../identifier" }
 dpp = { git = "https://github.com/dashpay/platform", branch = "master", default-features = false, features = [
     "data-contract-json-conversion",
-    "platform-value"
 ]}
+js-sys = "0.3.53"
 serde-wasm-bindgen = { git = "https://github.com/QuantumExplorer/serde-wasm-bindgen", branch = "feat/not_human_readable" }