@dashevo/wasm-dpp 0.24.0-dev.11 → 0.24.0-dev.13

package/src/identity/state_transition/asset_lock_proof/chain/chain_asset_lock_proof.rs

@@ -0,0 +1,132 @@
+use serde::{Deserialize, Serialize};
+use std::convert::TryInto;
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    buffer::Buffer,
+    errors::{from_dpp_err, RustConversionError},
+    identifier::IdentifierWrapper,
+    with_js_error,
+};
+use dpp::identity::state_transition::asset_lock_proof::chain::ChainAssetLockProof;
+use dpp::util::string_encoding;
+use dpp::util::string_encoding::Encoding;
+
+#[wasm_bindgen(js_name=ChainAssetLockProof)]
+#[derive(Clone)]
+pub struct ChainAssetLockProofWasm(ChainAssetLockProof);
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct ChainAssetLockProofParams {
+    #[serde(rename = "type")]
+    lock_type: u8,
+    core_chain_locked_height: u32,
+    out_point: Vec<u8>,
+}
+
+impl From<ChainAssetLockProof> for ChainAssetLockProofWasm {
+    fn from(v: ChainAssetLockProof) -> Self {
+        ChainAssetLockProofWasm(v)
+    }
+}
+
+impl From<ChainAssetLockProofWasm> for ChainAssetLockProof {
+    fn from(v: ChainAssetLockProofWasm) -> Self {
+        v.0
+    }
+}
+
+#[wasm_bindgen(js_class = ChainAssetLockProof)]
+impl ChainAssetLockProofWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(raw_parameters: JsValue) -> Result<ChainAssetLockProofWasm, JsValue> {
+        let parameters: ChainAssetLockProofParams =
+            with_js_error!(serde_wasm_bindgen::from_value(raw_parameters))?;
+
+        let out_point: [u8; 36] = parameters.out_point.try_into().map_err(|_| {
+            RustConversionError::Error(String::from("outPoint must be a 36 byte array"))
+                .to_js_value()
+        })?;
+
+        let chain_asset_lock_proof =
+            ChainAssetLockProof::new(parameters.core_chain_locked_height, out_point);
+
+        Ok(ChainAssetLockProofWasm(chain_asset_lock_proof))
+    }
+
+    #[wasm_bindgen(js_name=getType)]
+    pub fn get_type(&self) -> u8 {
+        ChainAssetLockProof::asset_lock_type()
+    }
+
+    #[wasm_bindgen(js_name=getCoreChainLockedHeight)]
+    pub fn get_core_chain_locked_height(&self) -> u32 {
+        self.0.core_chain_locked_height()
+    }
+
+    #[wasm_bindgen(js_name=setCoreChainLockedHeight)]
+    pub fn set_core_chain_locked_height(&mut self, value: u32) {
+        self.0.set_core_chain_locked_height(value);
+    }
+
+    #[wasm_bindgen(js_name=getOutPoint)]
+    pub fn get_out_point(&self) -> Buffer {
+        Buffer::from_bytes(self.0.out_point())
+    }
+
+    #[wasm_bindgen(js_name=setOutPoint)]
+    pub fn set_out_point(&mut self, out_point: Vec<u8>) -> Result<(), JsValue> {
+        let out_point: [u8; 36] = out_point.try_into().map_err(|_| {
+            RustConversionError::Error(String::from("outPoint must be a 36 byte array"))
+                .to_js_value()
+        })?;
+        self.0.set_out_point(out_point);
+
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name=toJSON)]
+    pub fn to_json(&self) -> Result<JsValue, JsValue> {
+        let js_object = self.to_object()?;
+
+        let out_point_base64 = string_encoding::encode(self.0.out_point(), Encoding::Base64);
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"outPoint".to_owned().into(),
+            &JsValue::from(out_point_base64),
+        )?;
+
+        Ok(js_object)
+    }
+
+    #[wasm_bindgen(js_name=toObject)]
+    pub fn to_object(&self) -> Result<JsValue, JsValue> {
+        let asset_lock_json =
+            serde_json::to_value(self.0.clone()).map_err(|e| from_dpp_err(e.into()))?;
+
+        let asset_lock_json_string =
+            serde_json::to_string(&asset_lock_json).map_err(|e| from_dpp_err(e.into()))?;
+        let js_object = js_sys::JSON::parse(&asset_lock_json_string)?;
+
+        let out_point = self.get_out_point();
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"outPoint".to_owned().into(),
+            &JsValue::from(out_point),
+        )?;
+
+        Ok(js_object)
+    }
+
+    #[wasm_bindgen(js_name=createIdentifier)]
+    pub fn create_identifier(&self) -> Result<IdentifierWrapper, JsValue> {
+        let identifier = self
+            .0
+            .create_identifier()
+            .map_err(|e| from_dpp_err(e.into()))?;
+        Ok(identifier.into())
+    }
+}

package/src/identity/state_transition/asset_lock_proof/chain/chain_asset_lock_proof_structure_validator.rs

@@ -0,0 +1,72 @@
+use dpp::identity::state_transition::asset_lock_proof::{
+    AssetLockTransactionValidator, ChainAssetLockProofStructureValidator,
+};
+use dpp::state_transition::state_transition_execution_context::StateTransitionExecutionContext;
+use dpp::ProtocolError;
+use std::sync::Arc;
+use wasm_bindgen::prelude::*;
+
+use crate::buffer::Buffer;
+use crate::utils::ToSerdeJSONExt;
+use crate::{
+    errors::from_dpp_err,
+    state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
+    validation::ValidationResultWasm,
+    StateTransitionExecutionContextWasm,
+};
+
+#[wasm_bindgen(js_name = ChainAssetLockProofStructureValidator)]
+pub struct ChainAssetLockProofStructureValidatorWasm(
+    ChainAssetLockProofStructureValidator<ExternalStateRepositoryLikeWrapper>,
+);
+
+impl From<ChainAssetLockProofStructureValidator<ExternalStateRepositoryLikeWrapper>>
+    for ChainAssetLockProofStructureValidatorWasm
+{
+    fn from(
+        validator: ChainAssetLockProofStructureValidator<ExternalStateRepositoryLikeWrapper>,
+    ) -> Self {
+        Self(validator)
+    }
+}
+
+#[wasm_bindgen(js_class = ChainAssetLockProofStructureValidator)]
+impl ChainAssetLockProofStructureValidatorWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        state_repository: ExternalStateRepositoryLike,
+    ) -> Result<ChainAssetLockProofStructureValidatorWasm, JsValue> {
+        let state_repository_wrapper =
+            Arc::new(ExternalStateRepositoryLikeWrapper::new(state_repository));
+
+        let tx_validator = Arc::new(AssetLockTransactionValidator::new(
+            state_repository_wrapper.clone(),
+        ));
+
+        let validator =
+            ChainAssetLockProofStructureValidator::new(state_repository_wrapper, tx_validator)
+                .map_err(|e| from_dpp_err(ProtocolError::Generic(e.to_string())))?;
+
+        Ok(validator.into())
+    }
+
+    #[wasm_bindgen]
+    pub async fn validate(
+        &self,
+        raw_asset_lock_proof: JsValue,
+        execution_context: &StateTransitionExecutionContextWasm,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let asset_lock_proof_json = raw_asset_lock_proof.with_serde_to_json_value()?;
+
+        let context: &StateTransitionExecutionContext = execution_context.into();
+        let validation_result = self
+            .0
+            .validate(&asset_lock_proof_json, context)
+            .await
+            .map_err(|e| from_dpp_err(e.into()))?;
+
+        Ok(validation_result
+            .map(|item| JsValue::from(Buffer::from_bytes(&item)))
+            .into())
+    }
+}

package/src/identity/state_transition/asset_lock_proof/chain/mod.rs

@@ -0,0 +1,4 @@
+pub use chain_asset_lock_proof::*;
+
+pub mod chain_asset_lock_proof;
+pub mod chain_asset_lock_proof_structure_validator;

package/src/identity/state_transition/asset_lock_proof/instant/instant_asset_lock_proof.rs

@@ -0,0 +1,177 @@
+use dpp::{
+    dashcore::{
+        blockdata::{script::Script, transaction::txout::TxOut},
+        consensus::encode::serialize,
+    },
+    util::string_encoding,
+    util::string_encoding::Encoding,
+};
+
+use serde::{Deserialize, Serialize};
+use std::convert::TryInto;
+use wasm_bindgen::prelude::*;
+
+use crate::{
+    buffer::Buffer,
+    errors::{from_dpp_err, RustConversionError},
+    identifier::IdentifierWrapper,
+    with_js_error,
+};
+use dpp::identity::state_transition::asset_lock_proof::instant::{
+    InstantAssetLockProof, RawInstantLock,
+};
+
+#[derive(Serialize, Deserialize)]
+#[serde(remote = "TxOut")]
+struct TxOutJS {
+    #[serde(rename = "satoshis")]
+    value: u64,
+    #[serde(rename = "script")]
+    script_pubkey: Script,
+}
+
+#[derive(Serialize)]
+struct TxOutSerdeHelper<'a>(#[serde(with = "TxOutJS")] &'a TxOut);
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+#[wasm_bindgen(js_name=InstantAssetLockProof)]
+pub struct InstantAssetLockProofWasm(InstantAssetLockProof);
+
+impl From<InstantAssetLockProof> for InstantAssetLockProofWasm {
+    fn from(v: InstantAssetLockProof) -> Self {
+        InstantAssetLockProofWasm(v)
+    }
+}
+
+impl From<InstantAssetLockProofWasm> for InstantAssetLockProof {
+    fn from(v: InstantAssetLockProofWasm) -> Self {
+        v.0
+    }
+}
+
+#[wasm_bindgen(js_class = InstantAssetLockProof)]
+impl InstantAssetLockProofWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(raw_parameters: JsValue) -> Result<InstantAssetLockProofWasm, JsValue> {
+        let raw_instant_lock: RawInstantLock =
+            with_js_error!(serde_wasm_bindgen::from_value(raw_parameters))?;
+
+        let instant_asset_lock_proof: InstantAssetLockProof =
+            raw_instant_lock.try_into().map_err(|_| {
+                RustConversionError::Error(String::from("object passed is not a raw Instant Lock"))
+                    .to_js_value()
+            })?;
+
+        Ok(instant_asset_lock_proof.into())
+    }
+
+    #[wasm_bindgen(js_name=getType)]
+    pub fn get_type(&self) -> u8 {
+        self.0.asset_lock_type()
+    }
+
+    #[wasm_bindgen(js_name=getOutputIndex)]
+    pub fn get_output_index(&self) -> usize {
+        self.0.output_index()
+    }
+
+    #[wasm_bindgen(js_name=getOutPoint)]
+    pub fn get_out_point(&self) -> Option<Buffer> {
+        self.0
+            .out_point()
+            .map(|out_point| Buffer::from_bytes(&out_point))
+    }
+
+    #[wasm_bindgen(js_name=getOutput)]
+    pub fn get_output(&self) -> Result<JsValue, JsValue> {
+        let output = self.0.output().unwrap();
+        let output_json_string =
+            serde_json::to_string(&TxOutSerdeHelper(output)).map_err(|e| from_dpp_err(e.into()))?;
+
+        let js_object = js_sys::JSON::parse(&output_json_string)?;
+        Ok(js_object)
+    }
+
+    #[wasm_bindgen(js_name=createIdentifier)]
+    pub fn create_identifier(&self) -> Result<IdentifierWrapper, JsValue> {
+        let identifier = self
+            .0
+            .create_identifier()
+            .map_err(|e| from_dpp_err(e.into()))?;
+        Ok(identifier.into())
+    }
+
+    #[wasm_bindgen(js_name=getInstantLock)]
+    pub fn get_instant_lock(&self) -> Buffer {
+        let instant_lock = self.0.instant_lock();
+        let serialized_instant_lock = serialize(instant_lock);
+        Buffer::from_bytes(&serialized_instant_lock)
+    }
+
+    #[wasm_bindgen(js_name=getTransaction)]
+    pub fn get_transaction(&self) -> Buffer {
+        let transaction = self.0.transaction();
+        let serialized_transaction = serialize(transaction);
+        Buffer::from_bytes(&serialized_transaction)
+    }
+
+    #[wasm_bindgen(js_name=toObject)]
+    pub fn to_object(&self) -> Result<JsValue, JsValue> {
+        let asset_lock_json =
+            serde_json::to_value(self.0.clone()).map_err(|e| from_dpp_err(e.into()))?;
+
+        let asset_lock_json_string =
+            serde_json::to_string(&asset_lock_json).map_err(|e| from_dpp_err(e.into()))?;
+        let js_object = js_sys::JSON::parse(&asset_lock_json_string)?;
+
+        let transaction = self.get_transaction();
+        let instant_lock = self.get_instant_lock();
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"transaction".to_owned().into(),
+            &JsValue::from(transaction),
+        )?;
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"instantLock".to_owned().into(),
+            &JsValue::from(instant_lock),
+        )?;
+
+        Ok(js_object)
+    }
+
+    #[wasm_bindgen(js_name=toJSON)]
+    pub fn to_json(&self) -> Result<JsValue, JsValue> {
+        let js_object = self.to_object()?;
+
+        let transaction = self.0.transaction();
+        let serialized_transaction = serialize(transaction);
+
+        let instant_lock = self.0.instant_lock();
+        let serialized_instant_lock = serialize(instant_lock);
+
+        let instant_lock_base64 =
+            string_encoding::encode(serialized_instant_lock.as_slice(), Encoding::Base64);
+
+        let mut transaction_hex = String::new();
+        for &byte in serialized_transaction.as_slice() {
+            transaction_hex.push_str(&format!("{:02x}", byte));
+        }
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"transaction".to_owned().into(),
+            &JsValue::from(transaction_hex),
+        )?;
+
+        js_sys::Reflect::set(
+            &js_object,
+            &"instantLock".to_owned().into(),
+            &JsValue::from(instant_lock_base64),
+        )?;
+
+        Ok(js_object)
+    }
+}

package/src/identity/state_transition/asset_lock_proof/instant/instant_asset_lock_proof_structure_validator.rs

@@ -0,0 +1,72 @@
+use dpp::identity::state_transition::asset_lock_proof::{
+    AssetLockTransactionValidator, InstantAssetLockProofStructureValidator,
+};
+use dpp::state_transition::state_transition_execution_context::StateTransitionExecutionContext;
+use dpp::ProtocolError;
+use std::sync::Arc;
+use wasm_bindgen::prelude::*;
+
+use crate::buffer::Buffer;
+use crate::utils::ToSerdeJSONExt;
+use crate::{
+    errors::from_dpp_err,
+    state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper},
+    validation::ValidationResultWasm,
+    StateTransitionExecutionContextWasm,
+};
+
+#[wasm_bindgen(js_name = InstantAssetLockProofStructureValidator)]
+pub struct InstantAssetLockProofStructureValidatorWasm(
+    InstantAssetLockProofStructureValidator<ExternalStateRepositoryLikeWrapper>,
+);
+
+impl From<InstantAssetLockProofStructureValidator<ExternalStateRepositoryLikeWrapper>>
+    for InstantAssetLockProofStructureValidatorWasm
+{
+    fn from(
+        validator: InstantAssetLockProofStructureValidator<ExternalStateRepositoryLikeWrapper>,
+    ) -> Self {
+        Self(validator)
+    }
+}
+
+#[wasm_bindgen(js_class = InstantAssetLockProofStructureValidator)]
+impl InstantAssetLockProofStructureValidatorWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        state_repository: ExternalStateRepositoryLike,
+    ) -> Result<InstantAssetLockProofStructureValidatorWasm, JsValue> {
+        let state_repository_wrapper =
+            Arc::new(ExternalStateRepositoryLikeWrapper::new(state_repository));
+
+        let tx_validator = Arc::new(AssetLockTransactionValidator::new(
+            state_repository_wrapper.clone(),
+        ));
+
+        let validator =
+            InstantAssetLockProofStructureValidator::new(state_repository_wrapper, tx_validator)
+                .map_err(|e| from_dpp_err(ProtocolError::Generic(e.to_string())))?;
+
+        Ok(validator.into())
+    }
+
+    #[wasm_bindgen]
+    pub async fn validate(
+        &self,
+        raw_asset_lock_proof: JsValue,
+        execution_context: &StateTransitionExecutionContextWasm,
+    ) -> Result<ValidationResultWasm, JsValue> {
+        let asset_lock_proof_json = raw_asset_lock_proof.with_serde_to_json_value()?;
+
+        let context: &StateTransitionExecutionContext = execution_context.into();
+        let validation_result = self
+            .0
+            .validate(&asset_lock_proof_json, context)
+            .await
+            .map_err(|e| from_dpp_err(e.into()))?;
+
+        Ok(validation_result
+            .map(|item| JsValue::from(Buffer::from_bytes(&item)))
+            .into())
+    }
+}

package/src/identity/state_transition/asset_lock_proof/instant/mod.rs

@@ -0,0 +1,4 @@
+pub use instant_asset_lock_proof::*;
+
+pub mod instant_asset_lock_proof;
+pub mod instant_asset_lock_proof_structure_validator;