@dashevo/wasm-dpp 0.24.0-dev.12 → 0.24.0-dev.14

package/src/identity/mod.rs

@@ -1,4 +1,6 @@
+mod factory_utils;
 pub mod identity_facade;
+mod identity_factory;
 mod identity_public_key;
 mod validation;
 
@@ -19,15 +21,24 @@ use crate::utils::to_vec_of_serde_values;
 use crate::MetadataWasm;
 pub use identity_public_key::*;
 
+pub use state_transition::*;
+
+pub mod errors;
+pub mod state_transition;
+
 #[wasm_bindgen(js_name=Identity)]
 #[derive(Clone)]
 pub struct IdentityWasm(Identity);
 
-#[wasm_bindgen(js_name=AssetLockProof)]
-pub struct AssetLockProofWasm(AssetLockProof);
-impl From<AssetLockProof> for AssetLockProofWasm {
-    fn from(v: AssetLockProof) -> Self {
-        AssetLockProofWasm(v)
+impl From<IdentityWasm> for Identity {
+    fn from(identity: IdentityWasm) -> Self {
+        identity.0
+    }
+}
+
+impl From<Identity> for IdentityWasm {
+    fn from(identity: Identity) -> Self {
+        Self(identity)
     }
 }
 
@@ -50,7 +61,7 @@ impl IdentityWasm {
 
     #[wasm_bindgen(js_name=getId)]
     pub fn get_id(&self) -> IdentifierWrapper {
-        self.0.get_id().clone().into()
+        (*self.0.get_id()).into()
     }
 
     #[wasm_bindgen(js_name=setPublicKeys)]
@@ -62,7 +73,7 @@ impl IdentityWasm {
 
         let public_keys = raw_public_keys
             .into_iter()
-            .map(IdentityPublicKey::from_json_object)
+            .map(|v| IdentityPublicKey::from_json_object(v).map(|key| (key.id, key)))
             .collect::<Result<_, _>>()
             .map_err(|e| format!("converting to collection of IdentityPublicKeys failed: {e:#}"))?;
 
@@ -76,7 +87,7 @@ impl IdentityWasm {
         self.0
             .get_public_keys()
             .iter()
-            .map(IdentityPublicKey::to_owned)
+            .map(|(_, k)| k.to_owned())
             .map(IdentityPublicKeyWasm::from)
             .map(JsValue::from)
             .collect()
@@ -112,9 +123,10 @@ impl IdentityWasm {
     }
 
     #[wasm_bindgen(js_name=setAssetLockProof)]
-    pub fn set_asset_lock_proof(&mut self, lock: JsValue) {
-        self.0
-            .set_asset_lock_proof(serde_wasm_bindgen::from_value(lock).unwrap());
+    pub fn set_asset_lock_proof(&mut self, lock: JsValue) -> Result<(), JsValue> {
+        let asset_lock_proof = create_asset_lock_proof_from_wasm_instance(&lock)?;
+        self.0.set_asset_lock_proof(asset_lock_proof);
+        Ok(())
     }
 
     #[wasm_bindgen(js_name=getAssetLockProof)]
@@ -159,7 +171,7 @@ impl IdentityWasm {
         let pks = self
             .0
             .public_keys
-            .iter()
+            .values()
             .map(|pk| pk.to_json())
             .collect::<Result<Vec<serde_json::Value>, SerdeParsingError>>()
             .map_err(|e| from_dpp_err(e.into()))?;
@@ -181,11 +193,11 @@ impl IdentityWasm {
     }
 
     #[wasm_bindgen(js_name=toObject)]
-    pub fn to_object(&self, _some_option: Option<bool>) -> Result<JsValue, JsValue> {
+    pub fn to_object(&self) -> Result<JsValue, JsValue> {
         let js_public_keys = js_sys::Array::new();
-        for pk in self.0.public_keys.iter() {
+        for pk in self.0.public_keys.values() {
             let pk_wasm = IdentityPublicKeyWasm::from(pk.to_owned());
-            js_public_keys.push(&pk_wasm.to_object(None)?);
+            js_public_keys.push(&pk_wasm.to_object()?);
         }
 
         let identity_json =
@@ -194,7 +206,7 @@ impl IdentityWasm {
             serde_json::to_string(&identity_json).map_err(|e| from_dpp_err(e.into()))?;
         let js_object = js_sys::JSON::parse(&identity_json_string)?;
 
-        let id: IdentifierWrapper = self.0.id.clone().into();
+        let id: IdentifierWrapper = self.0.id.into();
 
         js_sys::Reflect::set(
             &js_object,
@@ -222,7 +234,9 @@ impl IdentityWasm {
 
     #[wasm_bindgen(js_name=addPublicKey)]
     pub fn add_public_key(&mut self, public_key: IdentityPublicKeyWasm) {
-        self.0.public_keys.push(public_key.into());
+        self.0
+            .public_keys
+            .insert(public_key.get_id(), public_key.into());
     }
 
     // The method `addPublicKeys()` takes an variadic array of `IdentityPublicKeyWasm` as an input. But elements of the array

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;