@dashevo/wasm-dpp 0.25.0-dev.15 → 0.25.0-dev.17

package/src/identity/mod.rs

@@ -2,263 +2,32 @@ mod factory_utils;
 pub mod identity_facade;
 mod identity_factory;
 mod identity_public_key;
-mod validation;
-
-use js_sys::Array;
-use serde_json::Value;
-use wasm_bindgen::prelude::*;
-
-use dpp::identity::state_transition::asset_lock_proof::AssetLockProof;
-use dpp::identity::IdentityPublicKey;
-use dpp::identity::{Identity, KeyID};
-use dpp::metadata::Metadata;
-use dpp::serialization_traits::{PlatformDeserializable, PlatformSerializable};
-use dpp::{Convertible, ProtocolError};
-
-use crate::identifier::IdentifierWrapper;
-use crate::utils::{to_vec_of_serde_values, IntoWasm, WithJsError};
-use crate::MetadataWasm;
-use crate::{utils, with_js_error};
+// mod validation;
+//
+// use js_sys::Array;
+// use serde_json::Value;
+// use wasm_bindgen::prelude::*;
+//
+// use dpp::identity::state_transition::asset_lock_proof::AssetLockProof;
+// use dpp::identity::IdentityPublicKey;
+// use dpp::identity::{Identity, KeyID};
+// use dpp::metadata::Metadata;
+// use dpp::serialization::serialization_traits::{PlatformDeserializable, PlatformSerializable};
+// use dpp::{ ProtocolError};
+//
+// use crate::identifier::IdentifierWrapper;
+// use crate::utils::{to_vec_of_serde_values, IntoWasm, WithJsError};
+// use crate::MetadataWasm;
+// use crate::{utils, with_js_error};
 pub use identity_public_key::*;
-
-use crate::buffer::Buffer;
-use crate::errors::from_dpp_err;
-pub use state_transition::*;
-
-pub mod credits_converter;
+//
+// use crate::buffer::Buffer;
+// use crate::errors::from_dpp_err;
+// pub use state_transition::*;
+//
+// pub mod credits_converter;
 pub mod errors;
+mod identity;
 pub mod state_transition;
 
-#[wasm_bindgen(js_name=Identity)]
-#[derive(Clone)]
-pub struct IdentityWasm(Identity);
-
-impl From<IdentityWasm> for Identity {
-    fn from(identity: IdentityWasm) -> Self {
-        identity.0
-    }
-}
-
-impl From<Identity> for IdentityWasm {
-    fn from(identity: Identity) -> Self {
-        Self(identity)
-    }
-}
-
-#[wasm_bindgen(js_class=Identity)]
-impl IdentityWasm {
-    #[wasm_bindgen(constructor)]
-    pub fn new(raw_identity: JsValue) -> Result<IdentityWasm, JsValue> {
-        let identity_json = utils::stringify(&raw_identity)?;
-        let raw_identity: Value =
-            serde_json::from_str(&identity_json).map_err(|e| e.to_string())?;
-
-        let identity = Identity::from_json(raw_identity).map_err(from_dpp_err)?;
-        Ok(IdentityWasm(identity))
-    }
-
-    #[wasm_bindgen(js_name=getProtocolVersion)]
-    pub fn get_protocol_version(&self) -> u32 {
-        self.0.get_protocol_version()
-    }
-
-    #[wasm_bindgen(js_name=getId)]
-    pub fn get_id(&self) -> IdentifierWrapper {
-        (*self.0.get_id()).into()
-    }
-
-    #[wasm_bindgen(js_name=setPublicKeys)]
-    pub fn set_public_keys(&mut self, public_keys: js_sys::Array) -> Result<usize, JsValue> {
-        let raw_public_keys = to_vec_of_serde_values(public_keys.iter())?;
-        if raw_public_keys.is_empty() {
-            return Err(format!("Setting public keys failed. The input ('{}') is invalid. You must use array of PublicKeys", public_keys.to_string()).into());
-        }
-
-        let public_keys = raw_public_keys
-            .into_iter()
-            .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:#}"))?;
-
-        self.0.set_public_keys(public_keys);
-
-        Ok(self.0.get_public_keys().len())
-    }
-
-    #[wasm_bindgen(js_name=getPublicKeys)]
-    pub fn get_public_keys(&self) -> Vec<JsValue> {
-        self.0
-            .get_public_keys()
-            .iter()
-            .map(|(_, k)| k.to_owned())
-            .map(IdentityPublicKeyWasm::from)
-            .map(JsValue::from)
-            .collect()
-    }
-
-    #[wasm_bindgen(js_name=getPublicKeyById)]
-    pub fn get_public_key_by_id(&self, key_id: u32) -> Option<IdentityPublicKeyWasm> {
-        let key_id = key_id as KeyID;
-        self.0
-            .get_public_key_by_id(key_id)
-            .map(IdentityPublicKey::to_owned)
-            .map(Into::into)
-    }
-
-    #[wasm_bindgen(getter)]
-    pub fn balance(&self) -> f64 {
-        self.0.get_balance() as f64
-    }
-
-    #[wasm_bindgen(js_name=getBalance)]
-    pub fn get_balance(&self) -> f64 {
-        self.0.get_balance() as f64
-    }
-
-    #[wasm_bindgen(js_name=setBalance)]
-    pub fn set_balance(&mut self, balance: f64) {
-        self.0.set_balance(balance as u64);
-    }
-
-    #[wasm_bindgen(js_name=increaseBalance)]
-    pub fn increase_balance(&mut self, amount: f64) -> f64 {
-        self.0.increase_balance(amount as u64) as f64
-    }
-
-    #[wasm_bindgen(js_name=reduceBalance)]
-    pub fn reduce_balance(&mut self, amount: f64) -> f64 {
-        self.0.reduce_balance(amount as u64) as f64
-    }
-
-    #[wasm_bindgen(js_name=setAssetLockProof)]
-    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)]
-    pub fn get_asset_lock_proof(&self) -> Option<AssetLockProofWasm> {
-        self.0
-            .get_asset_lock_proof()
-            .map(AssetLockProof::to_owned)
-            .map(Into::into)
-    }
-
-    #[wasm_bindgen(js_name=setRevision)]
-    pub fn set_revision(&mut self, revision: f64) {
-        self.0.set_revision(revision as u64);
-    }
-
-    #[wasm_bindgen(js_name=getRevision)]
-    pub fn get_revision(&self) -> f64 {
-        self.0.get_revision() as f64
-    }
-
-    #[wasm_bindgen(js_name=setMetadata)]
-    pub fn set_metadata(&mut self, metadata: JsValue) -> Result<(), JsValue> {
-        if !metadata.is_falsy() {
-            let metadata = metadata.to_wasm::<MetadataWasm>("Metadata")?;
-            self.0.set_metadata(metadata.to_owned().into())
-        }
-
-        Ok(())
-    }
-
-    #[wasm_bindgen(js_name=getMetadata)]
-    pub fn get_metadata(&self) -> Option<MetadataWasm> {
-        self.0
-            .get_metadata()
-            .map(Metadata::to_owned)
-            .map(Into::into)
-    }
-
-    #[wasm_bindgen(js_name=from)]
-    pub fn from(object: JsValue) -> Self {
-        let i: Identity = serde_json::from_str(&object.as_string().unwrap()).unwrap();
-        IdentityWasm(i)
-    }
-
-    #[wasm_bindgen(js_name=toJSON)]
-    pub fn to_json(&self) -> Result<JsValue, JsValue> {
-        let json = self.0.to_json().with_js_error()?;
-        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
-        with_js_error!(json.serialize(&serializer))
-    }
-
-    #[wasm_bindgen(js_name=toObject)]
-    pub fn to_object(&self) -> Result<JsValue, JsValue> {
-        let js_public_keys = js_sys::Array::new();
-        for pk in self.0.public_keys.values() {
-            let pk_wasm = IdentityPublicKeyWasm::from(pk.to_owned());
-            js_public_keys.push(&pk_wasm.to_object()?);
-        }
-
-        let value = self.0.to_cleaned_object().with_js_error()?;
-
-        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
-        let js_object = with_js_error!(value.serialize(&serializer))?;
-
-        let id = Buffer::from_bytes(self.0.id.as_slice());
-
-        js_sys::Reflect::set(&js_object, &"id".to_owned().into(), &id)?;
-
-        js_sys::Reflect::set(
-            &js_object,
-            &"publicKeys".to_owned().into(),
-            &JsValue::from(&js_public_keys),
-        )?;
-
-        Ok(js_object)
-    }
-
-    #[wasm_bindgen(js_name=toBuffer)]
-    pub fn to_buffer(&self) -> Result<Buffer, JsValue> {
-        let bytes = PlatformSerializable::serialize(&self.0.clone()).with_js_error()?;
-        Ok(Buffer::from_bytes(&bytes))
-    }
-
-    #[wasm_bindgen]
-    pub fn hash(&self) -> Result<Vec<u8>, JsValue> {
-        self.0.hash().with_js_error()
-    }
-
-    #[wasm_bindgen(js_name=addPublicKey)]
-    pub fn add_public_key(&mut self, public_key: IdentityPublicKeyWasm) {
-        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
-    // are available ONLY as `JsValue`. WASM-bindgen uses output from `toJSON()` to store WASM-object as `JsValue`.
-    // `toJSON()` converts binary data to `base64` or `base58`. Therefore we need to use `from_json_object()` constructor to
-    // to convert strings back into bytes and get `IdentityPublicKeyWasm`
-    #[wasm_bindgen(js_name=addPublicKeys, variadic)]
-    pub fn add_public_keys(&mut self, js_public_keys: JsValue) -> Result<(), JsValue> {
-        let js_public_keys_array = Array::from(&js_public_keys);
-        let json_objects = to_vec_of_serde_values(js_public_keys_array.iter())?;
-
-        let public_keys: Vec<IdentityPublicKey> = json_objects
-            .into_iter()
-            .map(IdentityPublicKey::from_json_object)
-            .collect::<Result<Vec<IdentityPublicKey>, ProtocolError>>()
-            .with_js_error()?;
-
-        self.0
-            .add_public_keys(public_keys.into_iter().map(Into::into));
-        Ok(())
-    }
-
-    #[wasm_bindgen(js_name=getPublicKeyMaxId)]
-    pub fn get_public_ke_max_id(&self) -> f64 {
-        self.0.get_public_key_max_id() as f64
-    }
-
-    #[wasm_bindgen(js_name=fromBuffer)]
-    pub fn from_buffer(buffer: Vec<u8>) -> Result<IdentityWasm, JsValue> {
-        let identity: Identity =
-            PlatformDeserializable::deserialize(buffer.as_slice()).with_js_error()?;
-        Ok(identity.into())
-    }
-}
+pub use identity::*;

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

@@ -1,7 +1,6 @@
 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::*;

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

@@ -1,4 +1,6 @@
 pub use chain_asset_lock_proof::*;
 
 pub mod chain_asset_lock_proof;
-pub mod chain_asset_lock_proof_structure_validator;
+
+// TODO(versioning): restore?
+// pub mod chain_asset_lock_proof_structure_validator;

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

@@ -1,7 +1,6 @@
 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::*;

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

@@ -1,4 +1,6 @@
 pub use instant_asset_lock_proof::*;
 
 pub mod instant_asset_lock_proof;
-pub mod instant_asset_lock_proof_structure_validator;
+
+// TODO(versioning): restore?
+// pub mod instant_asset_lock_proof_structure_validator;

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

@@ -4,28 +4,21 @@ mod instant;
 pub use chain::*;
 pub use instant::*;
 use std::convert::TryInto;
-use std::sync::Arc;
 use wasm_bindgen::JsCast;
 use wasm_bindgen::__rt::Ref;
 
-use crate::errors::{from_dpp_err, RustConversionError};
-use dpp::dashcore::consensus;
-use dpp::dashcore::hashes::hex::FromHex;
+use crate::errors::RustConversionError;
+
 use dpp::identity::errors::UnknownAssetLockProofTypeError;
 use wasm_bindgen::prelude::*;
 
-use crate::buffer::Buffer;
-use crate::errors::dpp_error::from_dpp_error_ref;
 use crate::identifier::IdentifierWrapper;
 use crate::identity::errors::UnknownAssetLockProofTypeErrorWasm;
-use crate::state_repository::{ExternalStateRepositoryLike, ExternalStateRepositoryLikeWrapper};
+
 use crate::utils::generic_of_js_val;
-use crate::validation::ValidationResultWasm;
-use crate::{Deserialize, StateTransitionExecutionContextWasm};
-use dpp::identity::state_transition::asset_lock_proof::{
-    AssetLockProof, AssetLockProofType, AssetLockPublicKeyHashFetcher,
-    AssetLockTransactionOutputFetcher, AssetLockTransactionValidator,
-};
+
+use dpp::identity::state_transition::asset_lock_proof::{AssetLockProof, AssetLockProofType};
+use serde::Deserialize;
 
 #[derive(Deserialize, Clone)]
 #[wasm_bindgen(js_name=AssetLockProof)]
@@ -164,106 +157,109 @@ pub fn create_asset_lock_proof_from_wasm_instance(
     }
 }
 
-#[wasm_bindgen(js_name=validateAssetLockTransaction)]
-pub async fn validate_asset_lock_transaction(
-    state_repository: ExternalStateRepositoryLike,
-    raw_transaction: String,
-    output_index: usize,
-    execution_context: &StateTransitionExecutionContextWasm,
-) -> Result<ValidationResultWasm, JsValue> {
-    let tx_bytes = Vec::from_hex(&raw_transaction)
-        .map_err(|_| RustConversionError::Error(String::from("invalid transaction hex")))?;
-
-    let state_repository_wrapper =
-        Arc::new(ExternalStateRepositoryLikeWrapper::new(state_repository));
-
-    let validator = AssetLockTransactionValidator::new(state_repository_wrapper);
-
-    let result = validator
-        .validate(tx_bytes.as_slice(), output_index, execution_context.into())
-        .await
-        .map_err(|e| from_dpp_err(e.into()))?;
-
-    let validation_result = result.map(|item| {
-        let object = js_sys::Object::new();
-
-        js_sys::Reflect::set(
-            &object,
-            &"publicKeyHash".to_owned().into(),
-            &Buffer::from_bytes(&item.public_key_hash),
-        )
-        .unwrap();
-
-        let deserialized_tx = consensus::serialize(&item.transaction);
-
-        js_sys::Reflect::set(
-            &object,
-            &"transaction".to_owned().into(),
-            &Buffer::from_bytes(&deserialized_tx),
-        )
-        .unwrap();
-
-        object
-    });
-
-    Ok(validation_result.into())
-}
-
-#[wasm_bindgen(js_name=fetchAssetLockTransactionOutput)]
-pub async fn fetch_asset_lock_transaction_output(
-    state_repository: ExternalStateRepositoryLike,
-    raw_asset_lock_proof: JsValue,
-    execution_context: &StateTransitionExecutionContextWasm,
-) -> Result<JsValue, JsValue> {
-    let asset_lock_proof = create_asset_lock_proof_from_wasm_instance(&raw_asset_lock_proof)?;
-
-    let state_repository_wrapper =
-        Arc::new(ExternalStateRepositoryLikeWrapper::new(state_repository));
-
-    let fetcher = AssetLockTransactionOutputFetcher::new(state_repository_wrapper);
-
-    let fetch_result = fetcher
-        .fetch(&asset_lock_proof, execution_context.into())
-        .await
-        .map_err(|e| from_dpp_error_ref(&e))?;
-
-    let tx_out = js_sys::Object::new();
-
-    js_sys::Reflect::set(
-        &tx_out,
-        &"satoshis".to_owned().into(),
-        &(fetch_result.value as u32).into(),
-    )
-    .unwrap();
-
-    let script_hex = format!("{:x}", fetch_result.script_pubkey);
-
-    js_sys::Reflect::set(&tx_out, &"script".to_owned().into(), &script_hex.into()).unwrap();
-
-    Ok(tx_out.into())
-}
-
-#[wasm_bindgen(js_name=fetchAssetLockPublicKeyHash)]
-pub async fn fetch_asset_lock_public_key_hash(
-    state_repository: ExternalStateRepositoryLike,
-    raw_asset_lock_proof: JsValue,
-    execution_context: &StateTransitionExecutionContextWasm,
-) -> Result<JsValue, JsValue> {
-    let asset_lock_proof = create_asset_lock_proof_from_wasm_instance(&raw_asset_lock_proof)?;
-
-    let state_repository_wrapper =
-        Arc::new(ExternalStateRepositoryLikeWrapper::new(state_repository));
-
-    let tx_output_fetcher =
-        AssetLockTransactionOutputFetcher::new(state_repository_wrapper.clone());
-
-    let public_key_hash_fetcher =
-        AssetLockPublicKeyHashFetcher::new(state_repository_wrapper, Arc::new(tx_output_fetcher));
-
-    let fetch_result = public_key_hash_fetcher
-        .fetch_public_key_hash(asset_lock_proof, execution_context.into())
-        .await
-        .map_err(|e| from_dpp_error_ref(&e))?;
-
-    Ok(Buffer::from_bytes(&fetch_result).into())
-}
+// TODO(versioning): restore?
+// #[wasm_bindgen(js_name=validateAssetLockTransaction)]
+// pub async fn validate_asset_lock_transaction(
+//     state_repository: ExternalStateRepositoryLike,
+//     raw_transaction: String,
+//     output_index: usize,
+//     execution_context: &StateTransitionExecutionContextWasm,
+// ) -> Result<ValidationResultWasm, JsValue> {
+//     let tx_bytes = Vec::from_hex(&raw_transaction)
+//         .map_err(|_| RustConversionError::Error(String::from("invalid transaction hex")))?;
+//
+//     let state_repository_wrapper =
+//         Arc::new(ExternalStateRepositoryLikeWrapper::new(state_repository));
+//
+//     let validator = AssetLockTransactionValidator::new(state_repository_wrapper);
+//
+//     let result = validator
+//         .validate(tx_bytes.as_slice(), output_index, execution_context.into())
+//         .await
+//         .map_err(|e| from_dpp_err(e.into()))?;
+//
+//     let validation_result = result.map(|item| {
+//         let object = js_sys::Object::new();
+//
+//         js_sys::Reflect::set(
+//             &object,
+//             &"publicKeyHash".to_owned().into(),
+//             &Buffer::from_bytes(&item.public_key_hash),
+//         )
+//         .unwrap();
+//
+//         let deserialized_tx = consensus::serialize(&item.transaction);
+//
+//         js_sys::Reflect::set(
+//             &object,
+//             &"transaction".to_owned().into(),
+//             &Buffer::from_bytes(&deserialized_tx),
+//         )
+//         .unwrap();
+//
+//         object
+//     });
+//
+//     Ok(validation_result.into())
+// }
+
+// TODO(versioning): restore?
+// #[wasm_bindgen(js_name=fetchAssetLockTransactionOutput)]
+// pub async fn fetch_asset_lock_transaction_output(
+//     state_repository: ExternalStateRepositoryLike,
+//     raw_asset_lock_proof: JsValue,
+//     execution_context: &StateTransitionExecutionContextWasm,
+// ) -> Result<JsValue, JsValue> {
+//     let asset_lock_proof = create_asset_lock_proof_from_wasm_instance(&raw_asset_lock_proof)?;
+//
+//     let state_repository_wrapper =
+//         Arc::new(ExternalStateRepositoryLikeWrapper::new(state_repository));
+//
+//     let fetcher = AssetLockTransactionOutputFetcher::new(state_repository_wrapper);
+//
+//     let fetch_result = fetcher
+//         .fetch(&asset_lock_proof, execution_context.into())
+//         .await
+//         .map_err(|e| from_dpp_error_ref(&e))?;
+//
+//     let tx_out = js_sys::Object::new();
+//
+//     js_sys::Reflect::set(
+//         &tx_out,
+//         &"satoshis".to_owned().into(),
+//         &(fetch_result.value as u32).into(),
+//     )
+//     .unwrap();
+//
+//     let script_hex = format!("{:x}", fetch_result.script_pubkey);
+//
+//     js_sys::Reflect::set(&tx_out, &"script".to_owned().into(), &script_hex.into()).unwrap();
+//
+//     Ok(tx_out.into())
+// }
+
+// TODO(versioning): restore?
+// #[wasm_bindgen(js_name=fetchAssetLockPublicKeyHash)]
+// pub async fn fetch_asset_lock_public_key_hash(
+//     state_repository: ExternalStateRepositoryLike,
+//     raw_asset_lock_proof: JsValue,
+//     execution_context: &StateTransitionExecutionContextWasm,
+// ) -> Result<JsValue, JsValue> {
+//     let asset_lock_proof = create_asset_lock_proof_from_wasm_instance(&raw_asset_lock_proof)?;
+//
+//     let state_repository_wrapper =
+//         Arc::new(ExternalStateRepositoryLikeWrapper::new(state_repository));
+//
+//     let tx_output_fetcher =
+//         AssetLockTransactionOutputFetcher::new(state_repository_wrapper.clone());
+//
+//     let public_key_hash_fetcher =
+//         AssetLockPublicKeyHashFetcher::new(state_repository_wrapper, Arc::new(tx_output_fetcher));
+//
+//     let fetch_result = public_key_hash_fetcher
+//         .fetch_public_key_hash(asset_lock_proof, execution_context.into())
+//         .await
+//         .map_err(|e| from_dpp_error_ref(&e))?;
+//
+//     Ok(Buffer::from_bytes(&fetch_result).into())
+// }