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

package/src/identity/identity.rs

@@ -0,0 +1,275 @@
+use crate::buffer::Buffer;
+use crate::errors::from_dpp_err;
+use crate::identifier::IdentifierWrapper;
+use crate::identity::IdentityPublicKeyWasm;
+use crate::metadata::MetadataWasm;
+use crate::utils::{IntoWasm, WithJsError};
+use crate::{utils, with_js_error};
+use dpp::identity::accessors::{IdentityGettersV0, IdentitySettersV0};
+use dpp::identity::identity_public_key::accessors::v0::IdentityPublicKeyGettersV0;
+use dpp::identity::{Identity, IdentityPublicKey, KeyID};
+use dpp::metadata::Metadata;
+use dpp::platform_value::{ReplacementType, Value};
+use dpp::serialization::PlatformDeserializable;
+use dpp::serialization::PlatformSerializable;
+use dpp::serialization::ValueConvertible;
+use dpp::version::PlatformVersion;
+use serde::Serialize;
+use serde_json::Value as JsonValue;
+use wasm_bindgen::prelude::*;
+use wasm_bindgen::JsValue;
+
+#[wasm_bindgen(js_name=Identity)]
+#[derive(Clone)]
+pub struct IdentityWasm {
+    inner: Identity,
+    metadata: Option<Metadata>,
+}
+
+impl From<IdentityWasm> for Identity {
+    fn from(identity: IdentityWasm) -> Self {
+        identity.inner
+    }
+}
+
+impl From<Identity> for IdentityWasm {
+    fn from(identity: Identity) -> Self {
+        Self {
+            inner: identity,
+            metadata: None,
+        }
+    }
+}
+#[wasm_bindgen(js_class=Identity)]
+impl IdentityWasm {
+    #[wasm_bindgen(constructor)]
+    pub fn new(platform_version: u32) -> Result<IdentityWasm, JsValue> {
+        let platform_version =
+            &PlatformVersion::get(platform_version).map_err(|e| JsValue::from(e.to_string()))?;
+
+        Identity::default_versioned(&platform_version)
+            .map(Into::into)
+            .map_err(from_dpp_err)
+    }
+
+    #[wasm_bindgen(js_name=getId)]
+    pub fn get_id(&self) -> IdentifierWrapper {
+        self.inner.id().into()
+    }
+
+    #[wasm_bindgen(js_name=setId)]
+    pub fn set_id(&mut self, id: IdentifierWrapper) {
+        self.inner.set_id(id.into());
+    }
+
+    #[wasm_bindgen(js_name=setPublicKeys)]
+    pub fn set_public_keys(&mut self, public_keys: js_sys::Array) -> Result<usize, JsValue> {
+        if public_keys.length() == 0 {
+            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 = public_keys
+            .iter()
+            .into_iter()
+            .map(|key| {
+                key.to_wasm::<IdentityPublicKeyWasm>("IdentityPublicKey")
+                    .map(|key| {
+                        let key = IdentityPublicKey::from(key.to_owned());
+                        (key.id(), key)
+                    })
+            })
+            .collect::<Result<_, _>>()?;
+
+        self.inner.set_public_keys(public_keys);
+
+        Ok(self.inner.public_keys().len())
+    }
+
+    #[wasm_bindgen(js_name=getPublicKeys)]
+    pub fn get_public_keys(&self) -> Vec<JsValue> {
+        self.inner
+            .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.inner
+            .get_public_key_by_id(key_id)
+            .map(IdentityPublicKey::to_owned)
+            .map(Into::into)
+    }
+
+    #[wasm_bindgen(getter)]
+    pub fn balance(&self) -> f64 {
+        self.inner.balance() as f64
+    }
+
+    #[wasm_bindgen(js_name=getBalance)]
+    pub fn get_balance(&self) -> f64 {
+        self.inner.balance() as f64
+    }
+
+    #[wasm_bindgen(js_name=setBalance)]
+    pub fn set_balance(&mut self, balance: f64) {
+        self.inner.set_balance(balance as u64);
+    }
+
+    #[wasm_bindgen(js_name=increaseBalance)]
+    pub fn increase_balance(&mut self, amount: f64) -> f64 {
+        self.inner.increase_balance(amount as u64) as f64
+    }
+
+    #[wasm_bindgen(js_name=reduceBalance)]
+    pub fn reduce_balance(&mut self, amount: f64) -> f64 {
+        self.inner.reduce_balance(amount as u64) as f64
+    }
+
+    #[wasm_bindgen(js_name=setRevision)]
+    pub fn set_revision(&mut self, revision: f64) {
+        self.inner.set_revision(revision as u64);
+    }
+
+    #[wasm_bindgen(js_name=getRevision)]
+    pub fn get_revision(&self) -> f64 {
+        self.inner.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")?.to_owned();
+            self.metadata = Some(metadata.into());
+        }
+
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name=getMetadata)]
+    pub fn get_metadata(&self) -> Option<MetadataWasm> {
+        self.metadata.map(|metadata| metadata.to_owned().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 {
+            inner: i,
+            metadata: None,
+        }
+    }
+
+    #[wasm_bindgen(js_name=toJSON)]
+    pub fn to_json(&self) -> Result<JsValue, JsValue> {
+        let mut value = self.inner.to_object().with_js_error()?;
+
+        value
+            .replace_at_paths(
+                dpp::identity::IDENTIFIER_FIELDS_RAW_OBJECT,
+                ReplacementType::TextBase58,
+            )
+            .map_err(|e| e.to_string())?;
+
+        // Monkey patch public keys data to be deserializable
+        let public_keys = value
+            .get_array_mut_ref(dpp::identity::property_names::PUBLIC_KEYS)
+            .map_err(|e| e.to_string())?;
+
+        for key in public_keys.iter_mut() {
+            key.replace_at_paths(
+                dpp::identity::identity_public_key::BINARY_DATA_FIELDS,
+                ReplacementType::TextBase64,
+            )
+            .map_err(|e| e.to_string())?;
+        }
+
+        let json = value
+            .try_into_validating_json()
+            .map_err(|e| e.to_string())?
+            .to_string();
+
+        js_sys::JSON::parse(&json)
+    }
+
+    #[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.inner.public_keys().values() {
+            let pk_wasm = IdentityPublicKeyWasm::from(pk.to_owned());
+            js_public_keys.push(&pk_wasm.to_object()?);
+        }
+
+        let value = self.inner.to_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.inner.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_to_bytes(&self.inner.clone()).with_js_error()?;
+        Ok(Buffer::from_bytes(&bytes))
+    }
+
+    #[wasm_bindgen]
+    pub fn hash(&self) -> Result<Vec<u8>, JsValue> {
+        self.inner.hash().with_js_error()
+    }
+
+    #[wasm_bindgen(js_name=addPublicKey)]
+    pub fn add_public_key(&mut self, public_key: IdentityPublicKeyWasm) {
+        self.inner
+            .public_keys_mut()
+            .insert(public_key.get_id(), public_key.into());
+    }
+
+    #[wasm_bindgen(js_name=addPublicKeys)]
+    pub fn add_public_keys(&mut self, public_keys: js_sys::Array) -> Result<(), JsValue> {
+        if public_keys.length() == 0 {
+            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: Vec<IdentityPublicKey> = public_keys
+            .iter()
+            .into_iter()
+            .map(|key| {
+                key.to_wasm::<IdentityPublicKeyWasm>("IdentityPublicKey")
+                    .map(|key| key.to_owned().into())
+            })
+            .collect::<Result<_, _>>()?;
+
+        self.inner.add_public_keys(public_keys);
+
+        Ok(())
+    }
+
+    #[wasm_bindgen(js_name=getPublicKeyMaxId)]
+    pub fn get_public_key_max_id(&self) -> f64 {
+        self.inner.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_from_bytes(buffer.as_slice()).with_js_error()?;
+        Ok(identity.into())
+    }
+}

package/src/identity/identity_facade.rs

@@ -1,95 +1,88 @@
 use std::convert::TryInto;
 
-use std::sync::Arc;
-
 use wasm_bindgen::prelude::*;
 
-use dpp::identity::validation::PublicKeysValidator;
 use dpp::identity::{Identity, IdentityFacade};
 
-use crate::bls_adapter::BlsAdapter;
 use crate::buffer::Buffer;
 use crate::errors::{from_dpp_err, RustConversionError};
 use crate::identifier::IdentifierWrapper;
 use crate::identity::errors::InvalidIdentityError;
 
-use crate::utils::{ToSerdeJSONExt, WithJsError};
-use crate::validation::ValidationResultWasm;
-use crate::{
-    create_asset_lock_proof_from_wasm_instance, with_js_error, ChainAssetLockProofWasm,
+use crate::identity::state_transition::{
+    create_asset_lock_proof_from_wasm_instance, ChainAssetLockProofWasm,
     IdentityCreateTransitionWasm, IdentityCreditTransferTransitionWasm,
-    IdentityTopUpTransitionWasm, IdentityUpdateTransitionWasm, IdentityWasm,
-    InstantAssetLockProofWasm,
+    IdentityTopUpTransitionWasm, IdentityUpdateTransitionWasm, InstantAssetLockProofWasm,
 };
+
+use crate::utils::WithJsError;
+use crate::with_js_error;
 use dpp::dashcore::{consensus, InstantLock, Transaction};
 
-use dpp::version::ProtocolVersionValidator;
-use dpp::{Convertible, NonConsensusError};
+use crate::identity::IdentityWasm;
+use dpp::NonConsensusError;
 use serde::Deserialize;
 
 #[derive(Clone)]
 #[wasm_bindgen(js_name=IdentityFacade)]
-pub struct IdentityFacadeWasm(IdentityFacade<BlsAdapter>);
+pub struct IdentityFacadeWasm(IdentityFacade);
 
 impl IdentityFacadeWasm {
-    pub fn new(
-        protocol_version_validator: Arc<ProtocolVersionValidator>,
-        public_keys_validator: Arc<PublicKeysValidator<BlsAdapter>>,
-    ) -> IdentityFacadeWasm {
-        let identity_facade = IdentityFacade::new(
-            protocol_version_validator.protocol_version(),
-            protocol_version_validator,
-            public_keys_validator,
-        )
-        .unwrap();
+    pub fn new(protocol_version: u32) -> IdentityFacadeWasm {
+        let identity_facade = IdentityFacade::new(protocol_version);
 
         IdentityFacadeWasm(identity_facade)
     }
 }
 
+impl From<&IdentityFacade> for IdentityFacadeWasm {
+    fn from(identity_facade: &IdentityFacade) -> Self {
+        Self(identity_facade.to_owned())
+    }
+}
 #[wasm_bindgen(js_class=IdentityFacade)]
 impl IdentityFacadeWasm {
     #[wasm_bindgen]
     pub fn create(
         &self,
-        asset_lock_proof: JsValue,
+        id: IdentifierWrapper,
         public_keys: js_sys::Array,
     ) -> Result<IdentityWasm, JsValue> {
-        let (asset_lock_proof, public_keys) =
-            super::factory_utils::parse_create_args(asset_lock_proof, public_keys)?;
+        let public_keys = super::factory_utils::parse_public_keys(public_keys)?;
 
         self.0
-            .create(asset_lock_proof, public_keys)
+            .create(id.into(), public_keys)
             .map(|identity| identity.into())
             .with_js_error()
     }
 
-    #[wasm_bindgen(js_name=createFromObject)]
-    pub fn create_from_object(
-        &self,
-        identity_object: JsValue,
-        options: Option<js_sys::Object>,
-    ) -> Result<IdentityWasm, JsValue> {
-        let options: FromObjectOptions = if let Some(options) = options {
-            with_js_error!(serde_wasm_bindgen::from_value(options.into()))?
-        } else {
-            Default::default()
-        };
-
-        let raw_identity = identity_object.with_serde_to_platform_value()?;
-
-        let result = self
-            .0
-            .create_from_object(raw_identity, options.skip_validation.unwrap_or(false));
-
-        match result {
-            Ok(identity) => Ok(identity.into()),
-            Err(dpp::ProtocolError::InvalidIdentityError { errors, .. }) => {
-                Err(InvalidIdentityError::new(errors, identity_object).into())
-            }
-            Err(other) => Err(from_dpp_err(other)),
-        }
-    }
+    // TODO(versioning): not used anymore?
+    // #[wasm_bindgen(js_name=createFromObject)]
+    // pub fn create_from_object(
+    //     &self,
+    //     identity_object: JsValue,
+    //     options: Option<js_sys::Object>,
+    // ) -> Result<IdentityWasm, JsValue> {
+    //     let options: FromObjectOptions = if let Some(options) = options {
+    //         with_js_error!(serde_wasm_bindgen::from_value(options.into()))?
+    //     } else {
+    //         Default::default()
+    //     };
+    //
+    //     let raw_identity = identity_object.with_serde_to_platform_value()?;
+    //
+    //     let result = self
+    //         .0
+    //         .create_from_object(raw_identity, options.skip_validation.unwrap_or(false));
+    //
+    //     match result {
+    //         Ok(identity) => Ok(identity.into()),
+    //         Err(dpp::ProtocolError::InvalidIdentityError { errors, .. }) => {
+    //             Err(InvalidIdentityError::new(errors, identity_object).into())
+    //         }
+    //         Err(other) => Err(from_dpp_err(other)),
+    //     }
+    // }
 
     #[wasm_bindgen(js_name=createFromBuffer)]
     pub fn create_from_buffer(
@@ -116,17 +109,18 @@ impl IdentityFacadeWasm {
         }
     }
 
-    #[wasm_bindgen]
-    pub fn validate(&self, identity: &IdentityWasm) -> Result<ValidationResultWasm, JsValue> {
-        let identity: Identity = identity.to_owned().into();
-        let identity_json = identity.to_cleaned_object().with_js_error()?;
-
-        let validation_result = self
-            .0
-            .validate(&identity_json)
-            .map_err(|e| from_dpp_err(e.into()))?;
-        Ok(validation_result.map(|_| JsValue::undefined()).into())
-    }
+    // TODO(versioning): restore?
+    // #[wasm_bindgen]
+    // pub fn validate(&self, identity: &IdentityWasm) -> Result<ValidationResultWasm, JsValue> {
+    //     let identity: Identity = identity.to_owned().into();
+    //     let identity_json = identity.to_cleaned_object().with_js_error()?;
+    //
+    //     let validation_result = self
+    //         .0
+    //         .validate(&identity_json)
+    //         .map_err(|e| from_dpp_err(e.into()))?;
+    //     Ok(validation_result.map(|_| JsValue::undefined()).into())
+    // }
 
     #[wasm_bindgen(js_name=createInstantAssetLockProof)]
     pub fn create_instant_asset_lock_proof(
@@ -141,7 +135,7 @@ impl IdentityFacadeWasm {
         let asset_lock_transaction: Transaction =
             consensus::deserialize(&asset_lock_transaction).map_err(|e| e.to_string())?;
 
-        Ok(IdentityFacade::<BlsAdapter>::create_instant_lock_proof(
+        Ok(IdentityFacade::create_instant_lock_proof(
             instant_lock,
             asset_lock_transaction,
             output_index,
@@ -160,20 +154,25 @@ impl IdentityFacadeWasm {
                 .to_js_value()
         })?;
 
-        Ok(IdentityFacade::<BlsAdapter>::create_chain_asset_lock_proof(
-            core_chain_locked_height,
-            out_point,
+        Ok(
+            IdentityFacade::create_chain_asset_lock_proof(core_chain_locked_height, out_point)
+                .into(),
         )
-        .into())
     }
 
     #[wasm_bindgen(js_name=createIdentityCreateTransition)]
     pub fn create_identity_create_transition(
         &self,
         identity: &IdentityWasm,
+        asset_lock_proof: JsValue,
     ) -> Result<IdentityCreateTransitionWasm, JsValue> {
+        let asset_lock_proof = create_asset_lock_proof_from_wasm_instance(&asset_lock_proof)?;
+
         self.0
-            .create_identity_create_transition(Identity::from(identity.to_owned()))
+            .create_identity_create_transition(
+                Identity::from(identity.to_owned()),
+                asset_lock_proof,
+            )
             .map(Into::into)
             .with_js_error()
     }

package/src/identity/identity_factory.rs

@@ -1,35 +1,37 @@
-use crate::bls_adapter::BlsAdapter;
 use crate::buffer::Buffer;
 use crate::errors::{from_dpp_err, RustConversionError};
 use crate::identifier::IdentifierWrapper;
 use crate::identity::errors::InvalidIdentityError;
-use crate::identity::validation::IdentityValidatorWasm;
+
+use crate::identity::identity::IdentityWasm;
+use crate::identity::state_transition::ChainAssetLockProofWasm;
+use crate::identity::state_transition::IdentityCreditTransferTransitionWasm;
+use crate::identity::state_transition::InstantAssetLockProofWasm;
 
 use crate::{
-    create_asset_lock_proof_from_wasm_instance, with_js_error, ChainAssetLockProofWasm,
-    IdentityCreateTransitionWasm, IdentityCreditTransferTransitionWasm,
-    IdentityTopUpTransitionWasm, IdentityUpdateTransitionWasm, IdentityWasm,
-    InstantAssetLockProofWasm,
+    identity::state_transition::create_asset_lock_proof_from_wasm_instance,
+    identity::state_transition::IdentityCreateTransitionWasm,
+    identity::state_transition::IdentityTopUpTransitionWasm,
+    identity::state_transition::IdentityUpdateTransitionWasm, with_js_error,
 };
 use dpp::dashcore::{consensus, InstantLock, Transaction};
-use dpp::identity::factory::IdentityFactory;
 
 use dpp::prelude::Identity;
 
 use serde::Deserialize;
 use std::convert::TryInto;
 
-use std::sync::Arc;
+use crate::utils::WithJsError;
+use dpp::identity::identity_factory::IdentityFactory;
 
-use crate::utils::{with_serde_to_platform_value, WithJsError};
 use wasm_bindgen::prelude::wasm_bindgen;
 use wasm_bindgen::JsValue;
 
 #[wasm_bindgen(js_name=IdentityFactory)]
-pub struct IdentityFactoryWasm(IdentityFactory<BlsAdapter>);
+pub struct IdentityFactoryWasm(IdentityFactory);
 
-impl From<IdentityFactory<BlsAdapter>> for IdentityFactoryWasm {
-    fn from(factory: IdentityFactory<BlsAdapter>) -> Self {
+impl From<IdentityFactory> for IdentityFactoryWasm {
+    fn from(factory: IdentityFactory) -> Self {
         Self(factory)
     }
 }
@@ -37,55 +39,52 @@ impl From<IdentityFactory<BlsAdapter>> for IdentityFactoryWasm {
 #[wasm_bindgen(js_class=IdentityFactory)]
 impl IdentityFactoryWasm {
     #[wasm_bindgen(constructor)]
-    pub fn new(
-        protocol_version: u32,
-        identity_validator: IdentityValidatorWasm,
-    ) -> Result<IdentityFactoryWasm, JsValue> {
-        let factory = IdentityFactory::new(protocol_version, Arc::new(identity_validator.into()));
+    pub fn new(protocol_version: u32) -> Result<IdentityFactoryWasm, JsValue> {
+        let factory = IdentityFactory::new(protocol_version);
         Ok(factory.into())
     }
 
     #[wasm_bindgen]
     pub fn create(
         &self,
-        asset_lock_proof: JsValue,
+        id: IdentifierWrapper,
         public_keys: js_sys::Array,
     ) -> Result<IdentityWasm, JsValue> {
-        let (asset_lock_proof, public_keys) =
-            super::factory_utils::parse_create_args(asset_lock_proof, public_keys)?;
+        let public_keys = super::factory_utils::parse_public_keys(public_keys)?;
 
         self.0
-            .create(asset_lock_proof, public_keys)
+            .create(id.into(), public_keys)
             .map(|identity| identity.into())
             .with_js_error()
     }
 
-    #[wasm_bindgen(js_name=createFromObject)]
-    pub fn create_from_object(
-        &self,
-        identity_object: JsValue,
-        options: JsValue,
-    ) -> Result<IdentityWasm, JsValue> {
-        let options: FromObjectOptions = if options.is_object() {
-            with_js_error!(serde_wasm_bindgen::from_value(options))?
-        } else {
-            Default::default()
-        };
-
-        let raw_identity = with_serde_to_platform_value(&identity_object)?;
-
-        let result = self
-            .0
-            .create_from_object(raw_identity, options.skip_validation.unwrap_or(false));
-
-        match result {
-            Ok(identity) => Ok(identity.into()),
-            Err(dpp::ProtocolError::InvalidIdentityError { errors, .. }) => {
-                Err(InvalidIdentityError::new(errors, identity_object).into())
-            }
-            Err(other) => Err(from_dpp_err(other)),
-        }
-    }
+    // TODO(versioning): not used anymore?
+    // #[wasm_bindgen(js_name=createFromObject)]
+    // pub fn create_from_object(
+    //     &self,
+    //     identity_object: JsValue,
+    //     options: JsValue,
+    // ) -> Result<IdentityWasm, JsValue> {
+    //     let options: FromObjectOptions = if options.is_object() {
+    //         with_js_error!(serde_wasm_bindgen::from_value(options))?
+    //     } else {
+    //         Default::default()
+    //     };
+    //
+    //     let raw_identity = with_serde_to_platform_value(&identity_object)?;
+    //
+    //     let result = self
+    //         .0
+    //         .create_from_object(raw_identity);
+    //
+    //     match result {
+    //         Ok(identity) => Ok(identity.into()),
+    //         Err(dpp::ProtocolError::InvalidIdentityError { errors, .. }) => {
+    //             Err(InvalidIdentityError::new(errors, identity_object).into())
+    //         }
+    //         Err(other) => Err(from_dpp_err(other)),
+    //     }
+    // }
 
     #[wasm_bindgen(js_name=createFromBuffer)]
     pub fn create_from_buffer(
@@ -101,7 +100,7 @@ impl IdentityFactoryWasm {
 
         let result = self
             .0
-            .create_from_buffer(buffer.clone(), options.skip_validation.unwrap_or(false));
+            .create_from_buffer(buffer.clone(), options.skip_validation.unwrap_or(true));
 
         match result {
             Ok(identity) => Ok(identity.into()),
@@ -125,7 +124,7 @@ impl IdentityFactoryWasm {
         let asset_lock_transaction: Transaction =
             consensus::deserialize(&asset_lock_transaction).map_err(|e| e.to_string())?;
 
-        Ok(IdentityFactory::<BlsAdapter>::create_instant_lock_proof(
+        Ok(IdentityFactory::create_instant_lock_proof(
             instant_lock,
             asset_lock_transaction,
             output_index,
@@ -145,11 +144,8 @@ impl IdentityFactoryWasm {
         })?;
 
         Ok(
-            IdentityFactory::<BlsAdapter>::create_chain_asset_lock_proof(
-                core_chain_locked_height,
-                out_point,
-            )
-            .into(),
+            IdentityFactory::create_chain_asset_lock_proof(core_chain_locked_height, out_point)
+                .into(),
         )
     }
 
@@ -157,9 +153,15 @@ impl IdentityFactoryWasm {
     pub fn create_identity_create_transition(
         &self,
         identity: &IdentityWasm,
+        asset_lock_proof: &JsValue,
     ) -> Result<IdentityCreateTransitionWasm, JsValue> {
+        let asset_lock_proof = create_asset_lock_proof_from_wasm_instance(&asset_lock_proof)?;
+
         self.0
-            .create_identity_create_transition(Identity::from(identity.to_owned()))
+            .create_identity_create_transition(
+                Identity::from(identity.to_owned()),
+                asset_lock_proof,
+            )
             .map(Into::into)
             .with_js_error()
     }