@dashevo/wasm-dpp 0.25.0-dev.8 → 0.25.0-pr.1545.2

package/src/identity/mod.rs

@@ -2,254 +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::{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) -> Vec<u8> {
-        self.0.to_cbor_buffer().unwrap()
-    }
-
-    #[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
-    }
-}
+pub use identity::*;

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

@@ -1,3 +1,6 @@
+use dpp::dashcore::consensus::Encodable;
+use dpp::dashcore::OutPoint;
+use dpp::identity::state_transition::asset_lock_proof::AssetLockProofType;
 use serde::{Deserialize, Serialize};
 use std::convert::TryInto;
 use wasm_bindgen::prelude::*;
@@ -10,8 +13,8 @@ use crate::{
     with_js_error,
 };
 use dpp::identity::state_transition::asset_lock_proof::chain::ChainAssetLockProof;
+use dpp::platform_value::string_encoding;
 use dpp::platform_value::string_encoding::Encoding;
-use dpp::platform_value::{string_encoding, Bytes36};
 
 #[wasm_bindgen(js_name=ChainAssetLockProof)]
 #[derive(Clone)]
@@ -20,8 +23,6 @@ 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>,
 }
@@ -41,14 +42,14 @@ impl From<ChainAssetLockProofWasm> for ChainAssetLockProof {
 #[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))?;
+    pub fn new(raw_parameters: JsValue) -> Result<ChainAssetLockProofWasm, JsError> {
+        let parameters: ChainAssetLockProofParams = serde_wasm_bindgen::from_value(raw_parameters)
+            .map_err(|_| JsError::new("invalid raw chain lock proof"))?;
 
-        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 out_point: [u8; 36] = parameters
+            .out_point
+            .try_into()
+            .map_err(|_| JsError::new("outPoint must be a 36 byte array"))?;
 
         let chain_asset_lock_proof =
             ChainAssetLockProof::new(parameters.core_chain_locked_height, out_point);
@@ -58,7 +59,7 @@ impl ChainAssetLockProofWasm {
 
     #[wasm_bindgen(js_name=getType)]
     pub fn get_type(&self) -> u8 {
-        ChainAssetLockProof::asset_lock_type()
+        AssetLockProofType::Chain as u8
     }
 
     #[wasm_bindgen(js_name=getCoreChainLockedHeight)]
@@ -72,8 +73,15 @@ impl ChainAssetLockProofWasm {
     }
 
     #[wasm_bindgen(js_name=getOutPoint)]
-    pub fn get_out_point(&self) -> Buffer {
-        Buffer::from_bytes_owned(self.0.out_point.to_vec())
+    pub fn get_out_point(&self) -> Result<Buffer, JsValue> {
+        let mut outpoint_bytes = Vec::new();
+
+        self.0
+            .out_point
+            .consensus_encode(&mut outpoint_bytes)
+            .map_err(|e| e.to_string())?;
+
+        Ok(Buffer::from_bytes_owned(outpoint_bytes))
     }
 
     #[wasm_bindgen(js_name=setOutPoint)]
@@ -82,7 +90,8 @@ impl ChainAssetLockProofWasm {
             RustConversionError::Error(String::from("outPoint must be a 36 byte array"))
                 .to_js_value()
         })?;
-        self.0.out_point = Bytes36::new(out_point);
+
+        self.0.out_point = OutPoint::from(out_point);
 
         Ok(())
     }
@@ -91,8 +100,14 @@ impl ChainAssetLockProofWasm {
     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.as_slice(), Encoding::Base64);
+        let mut outpoint_bytes = Vec::new();
+
+        self.0
+            .out_point
+            .consensus_encode(&mut outpoint_bytes)
+            .map_err(|e| e.to_string())?;
+
+        let out_point_base64 = string_encoding::encode(&outpoint_bytes, Encoding::Base64);
 
         js_sys::Reflect::set(
             &js_object,
@@ -110,7 +125,7 @@ impl ChainAssetLockProofWasm {
         let serializer = serde_wasm_bindgen::Serializer::json_compatible();
         let js_object = with_js_error!(asset_lock_value.serialize(&serializer))?;
 
-        let out_point = self.get_out_point();
+        let out_point = self.get_out_point()?;
 
         js_sys::Reflect::set(
             &js_object,

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.rs

@@ -1,8 +1,10 @@
 use dpp::dashcore::{
-    blockdata::{script::Script, transaction::txout::TxOut},
+    blockdata::{script::ScriptBuf, transaction::txout::TxOut},
     consensus::encode::serialize,
 };
 
+use dpp::dashcore::consensus::Encodable;
+use dpp::identity::state_transition::asset_lock_proof::AssetLockProofType;
 use serde::{Deserialize, Serialize};
 use std::convert::TryInto;
 use wasm_bindgen::prelude::*;
@@ -15,7 +17,7 @@ use crate::{
     with_js_error,
 };
 use dpp::identity::state_transition::asset_lock_proof::instant::{
-    InstantAssetLockProof, RawInstantLock,
+    InstantAssetLockProof, RawInstantLockProof,
 };
 use dpp::platform_value::string_encoding;
 use dpp::platform_value::string_encoding::Encoding;
@@ -26,7 +28,7 @@ struct TxOutJS {
     #[serde(rename = "satoshis")]
     value: u64,
     #[serde(rename = "script")]
-    script_pubkey: Script,
+    script_pubkey: ScriptBuf,
 }
 
 #[derive(Serialize)]
@@ -51,34 +53,41 @@ impl From<InstantAssetLockProofWasm> for InstantAssetLockProof {
 #[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))?;
+    pub fn new(raw_parameters: JsValue) -> Result<InstantAssetLockProofWasm, JsError> {
+        let raw_instant_lock: RawInstantLockProof = serde_wasm_bindgen::from_value(raw_parameters)
+            .map_err(|_| JsError::new("invalid raw instant lock proof"))?;
 
-        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()
-            })?;
+        let instant_asset_lock_proof: InstantAssetLockProof = raw_instant_lock
+            .try_into()
+            .map_err(|_| JsError::new("object passed is not a raw Instant Lock"))?;
 
         Ok(instant_asset_lock_proof.into())
     }
 
     #[wasm_bindgen(js_name=getType)]
     pub fn get_type(&self) -> u8 {
-        self.0.asset_lock_type()
+        AssetLockProofType::Instant as u8
     }
 
     #[wasm_bindgen(js_name=getOutputIndex)]
-    pub fn get_output_index(&self) -> usize {
+    pub fn get_output_index(&self) -> u32 {
         self.0.output_index()
     }
 
     #[wasm_bindgen(js_name=getOutPoint)]
-    pub fn get_out_point(&self) -> Option<Buffer> {
+    pub fn get_out_point(&self) -> Result<Option<Buffer>, JsValue> {
         self.0
             .out_point()
-            .map(|out_point| Buffer::from_bytes(&out_point))
+            .map(|out_point| {
+                let mut outpoint_bytes = Vec::new();
+
+                out_point
+                    .consensus_encode(&mut outpoint_bytes)
+                    .map_err(|e| e.to_string())?;
+
+                Ok(Buffer::from_bytes_owned(outpoint_bytes))
+            })
+            .transpose()
     }
 
     #[wasm_bindgen(js_name=getOutput)]

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;