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

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)]
@@ -63,7 +56,7 @@ pub trait AssetLockProofLike {
 impl AssetLockProofWasm {
     #[wasm_bindgen(constructor)]
     pub fn new(raw_asset_lock_proof: JsValue) -> Result<AssetLockProofWasm, JsValue> {
-        let lock_type = get_lock_type(&raw_asset_lock_proof)?;
+        let lock_type = get_type_from_raw_asset_lock_proof(&raw_asset_lock_proof)?;
 
         match lock_type {
             AssetLockProofType::Instant => {
@@ -100,21 +93,22 @@ impl AssetLockProofWasm {
     }
 }
 
-fn get_lock_type(raw_asset_lock_proof: &JsValue) -> Result<AssetLockProofType, JsValue> {
-    (js_sys::Reflect::get(raw_asset_lock_proof, &JsValue::from_str("type"))
-        .map_err(|_| {
-            RustConversionError::Error(String::from("error getting type from raw asset lock"))
-                .to_js_value()
-        })?
+fn get_type_from_raw_asset_lock_proof(
+    raw_asset_lock_proof: &JsValue,
+) -> Result<AssetLockProofType, JsError> {
+    let proof_type = js_sys::Reflect::get(raw_asset_lock_proof, &JsValue::from_str("type"))
+        .map_err(|_| JsError::new("error getting type from raw asset lock"))?
         .as_f64()
-        .ok_or_else(|| JsValue::from_str("asset lock type must be a number"))? as u64)
+        .ok_or_else(|| JsError::new("asset lock type must be a number"))?;
+
+    (proof_type as u64)
         .try_into()
-        .map_err(|_| JsValue::from_str("unrecognized asset lock proof type"))
+        .map_err(|_| JsError::new("unrecognized asset lock proof type"))
 }
 
 #[wasm_bindgen(js_name=createAssetLockProofInstance)]
-pub fn create_asset_lock_proof_instance(raw_parameters: JsValue) -> Result<JsValue, JsValue> {
-    let lock_type = get_lock_type(&raw_parameters)?;
+pub fn create_asset_lock_proof_instance(raw_parameters: JsValue) -> Result<JsValue, JsError> {
+    let lock_type = get_type_from_raw_asset_lock_proof(&raw_parameters)?;
 
     match lock_type {
         AssetLockProofType::Instant => {
@@ -164,106 +158,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())
+// }

package/src/identity/state_transition/identity_create_transition/identity_create_transition.rs

@@ -1,35 +1,42 @@
-use std::convert::TryInto;
+use dpp::platform_value::Value;
+use serde_json::Value as JsonValue;
 use std::default::Default;
 
 use wasm_bindgen::__rt::Ref;
 use wasm_bindgen::prelude::*;
 
+use crate::bls_adapter::BlsAdapter;
+use crate::errors::from_dpp_err;
+use dpp::identity::KeyType;
+use dpp::platform_value::BinaryData;
+use dpp::version::PlatformVersion;
+
 use crate::identifier::IdentifierWrapper;
 
+use crate::identity::state_transition::asset_lock_proof::create_asset_lock_proof_from_wasm_instance;
+use dpp::identity::state_transition::AssetLockProved;
+
 use crate::{
     buffer::Buffer,
-    create_asset_lock_proof_from_wasm_instance,
     errors::RustConversionError,
     identity::state_transition::asset_lock_proof::{
         ChainAssetLockProofWasm, InstantAssetLockProofWasm,
     },
     identity::state_transition::identity_public_key_transitions::IdentityPublicKeyWithWitnessWasm,
-    with_js_error,
+    utils, with_js_error,
 };
 
-use crate::bls_adapter::{BlsAdapter, JsBlsAdapter};
-use crate::errors::from_dpp_err;
-use dpp::state_transition::StateTransitionConvert;
-
-use crate::utils::{generic_of_js_val, ToSerdeJSONExt, WithJsError};
-use dpp::identity::KeyType;
+use crate::bls_adapter::JsBlsAdapter;
+use crate::utils::{generic_of_js_val, WithJsError};
+use dpp::platform_value::string_encoding;
 use dpp::platform_value::string_encoding::Encoding;
-use dpp::platform_value::{string_encoding, BinaryData};
+use dpp::serialization::{PlatformSerializable, ValueConvertible};
+use dpp::state_transition::identity_create_transition::accessors::IdentityCreateTransitionAccessorsV0;
+use dpp::state_transition::StateTransition;
 use dpp::{
-    identity::state_transition::{
-        asset_lock_proof::AssetLockProof, identity_create_transition::IdentityCreateTransition,
-        identity_public_key_transitions::IdentityPublicKeyInCreationWithWitness,
-    },
+    identity::state_transition::asset_lock_proof::AssetLockProof,
+    state_transition::identity::identity_create_transition::IdentityCreateTransition,
+    state_transition::identity::public_key_in_creation::IdentityPublicKeyInCreation,
     state_transition::StateTransitionLike,
 };
 
@@ -52,14 +59,13 @@ impl From<IdentityCreateTransitionWasm> for IdentityCreateTransition {
 #[wasm_bindgen(js_class = IdentityCreateTransition)]
 impl IdentityCreateTransitionWasm {
     #[wasm_bindgen(constructor)]
-    pub fn new(raw_parameters: JsValue) -> Result<IdentityCreateTransitionWasm, JsValue> {
-        let mut raw_state_transition = raw_parameters.with_serde_to_platform_value()?;
-        IdentityCreateTransition::clean_value(&mut raw_state_transition).with_js_error()?;
-        let identity_create_transition =
-            IdentityCreateTransition::from_raw_object(raw_state_transition)
-                .map_err(|e| RustConversionError::Error(e.to_string()).to_js_value())?;
-
-        Ok(identity_create_transition.into())
+    pub fn new(platform_version: u32) -> Result<IdentityCreateTransitionWasm, JsValue> {
+        let platform_version =
+            &PlatformVersion::get(platform_version).map_err(|e| JsValue::from(e.to_string()))?;
+
+        IdentityCreateTransition::default_versioned(&platform_version)
+            .map(Into::into)
+            .map_err(from_dpp_err)
     }
 
     #[wasm_bindgen(js_name=setAssetLockProof)]
@@ -80,7 +86,7 @@ impl IdentityCreateTransitionWasm {
 
     #[wasm_bindgen(js_name=getAssetLockProof)]
     pub fn get_asset_lock_proof(&self) -> JsValue {
-        let asset_lock_proof = self.0.get_asset_lock_proof().to_owned();
+        let asset_lock_proof = self.0.asset_lock_proof().to_owned();
 
         match asset_lock_proof {
             AssetLockProof::Chain(chain_asset_lock_proof) => {
@@ -104,7 +110,7 @@ impl IdentityCreateTransitionWasm {
                     )?;
                 Ok(public_key.clone().into())
             })
-            .collect::<Result<Vec<IdentityPublicKeyInCreationWithWitness>, JsValue>>()?;
+            .collect::<Result<Vec<IdentityPublicKeyInCreation>, JsValue>>()?;
 
         self.0.set_public_keys(public_keys);
 
@@ -123,7 +129,7 @@ impl IdentityCreateTransitionWasm {
                     )?;
                 Ok(public_key.clone().into())
             })
-            .collect::<Result<Vec<IdentityPublicKeyInCreationWithWitness>, JsValue>>()?;
+            .collect::<Result<Vec<IdentityPublicKeyInCreation>, JsValue>>()?;
 
         self.0.add_public_keys(&mut public_keys);
 
@@ -133,9 +139,9 @@ impl IdentityCreateTransitionWasm {
     #[wasm_bindgen(js_name=getPublicKeys)]
     pub fn get_public_keys(&self) -> Vec<JsValue> {
         self.0
-            .get_public_keys()
+            .public_keys()
             .iter()
-            .map(IdentityPublicKeyInCreationWithWitness::to_owned)
+            .map(IdentityPublicKeyInCreation::to_owned)
             .map(IdentityPublicKeyWithWitnessWasm::from)
             .map(JsValue::from)
             .collect()
@@ -148,7 +154,7 @@ impl IdentityCreateTransitionWasm {
 
     #[wasm_bindgen(js_name=getType)]
     pub fn get_type(&self) -> u8 {
-        self.0.get_type() as u8
+        self.0.state_transition_type() as u8
     }
 
     #[wasm_bindgen(getter, js_name=identityId)]
@@ -158,12 +164,12 @@ impl IdentityCreateTransitionWasm {
 
     #[wasm_bindgen(js_name=getIdentityId)]
     pub fn get_identity_id(&self) -> IdentifierWrapper {
-        (*self.0.get_identity_id()).into()
+        self.0.identity_id().into()
     }
 
     #[wasm_bindgen(js_name=getOwnerId)]
     pub fn get_owner_id(&self) -> IdentifierWrapper {
-        (*self.0.get_owner_id()).into()
+        (IdentityCreateTransitionAccessorsV0::owner_id(&self.0)).into()
     }
 
     #[wasm_bindgen(js_name=toObject)]
@@ -174,22 +180,22 @@ impl IdentityCreateTransitionWasm {
             Default::default()
         };
 
-        let _skip_signature = opts.skip_signature;
-        let object = super::to_object::to_object_struct(&self.0, opts);
+        let object = super::to_object::to_object_struct(&self.0, &opts);
+
         let js_object = js_sys::Object::new();
 
+        let version = match self.0 {
+            IdentityCreateTransition::V0(_) => "0",
+        };
+
+        js_sys::Reflect::set(&js_object, &"$version".to_owned().into(), &version.into())?;
+
         js_sys::Reflect::set(
             &js_object,
             &"type".to_owned().into(),
             &object.transition_type.into(),
         )?;
 
-        js_sys::Reflect::set(
-            &js_object,
-            &"protocolVersion".to_owned().into(),
-            &object.protocol_version.into(),
-        )?;
-
         if let Some(signature) = object.signature {
             let signature_value: JsValue = if signature.is_empty() {
                 JsValue::undefined()
@@ -219,7 +225,7 @@ impl IdentityCreateTransitionWasm {
             .public_keys
             .into_iter()
             .map(IdentityPublicKeyWithWitnessWasm::from)
-            .map(|key| key.to_object(options.clone()))
+            .map(|key| key.to_object(opts.skip_signature.unwrap_or(false)))
             .collect::<Result<js_sys::Array, _>>()?;
 
         js_sys::Reflect::set(&js_object, &"publicKeys".to_owned().into(), &keys_objects)?;
@@ -228,38 +234,31 @@ impl IdentityCreateTransitionWasm {
     }
 
     #[wasm_bindgen(js_name=toBuffer)]
-    pub fn to_buffer(&self, options: JsValue) -> Result<JsValue, JsValue> {
-        let opts: super::to_object::ToObjectOptions = if options.is_object() {
-            with_js_error!(serde_wasm_bindgen::from_value(options))?
-        } else {
-            Default::default()
-        };
-
-        let buffer = self
-            .0
-            .to_cbor_buffer(opts.skip_signature.unwrap_or(false))
-            .map_err(from_dpp_err)?;
-
-        Ok(Buffer::from_bytes(&buffer).into())
+    pub fn to_buffer(&self) -> Result<Buffer, JsValue> {
+        let bytes = PlatformSerializable::serialize_to_bytes(&StateTransition::IdentityCreate(
+            self.0.clone(),
+        ))
+        .with_js_error()?;
+        Ok(Buffer::from_bytes(&bytes))
     }
 
     #[wasm_bindgen(js_name=toJSON)]
     pub fn to_json(&self) -> Result<JsValue, JsValue> {
-        let object = super::to_object::to_object_struct(&self.0, Default::default());
+        let object = super::to_object::to_object_struct(&self.0, &Default::default());
         let js_object = js_sys::Object::new();
 
+        let version = match self.0 {
+            IdentityCreateTransition::V0(_) => "0",
+        };
+
+        js_sys::Reflect::set(&js_object, &"$version".to_owned().into(), &version.into())?;
+
         js_sys::Reflect::set(
             &js_object,
             &"type".to_owned().into(),
             &object.transition_type.into(),
         )?;
 
-        js_sys::Reflect::set(
-            &js_object,
-            &"protocolVersion".to_owned().into(),
-            &object.protocol_version.into(),
-        )?;
-
         if let Some(signature) = object.signature {
             let signature_value: JsValue = if signature.is_empty() {
                 JsValue::undefined()
@@ -298,8 +297,8 @@ impl IdentityCreateTransitionWasm {
     }
 
     #[wasm_bindgen(js_name=getModifiedDataIds)]
-    pub fn get_modified_data_ids(&self) -> Vec<IdentifierWrapper> {
-        let ids = self.0.get_modified_data_ids();
+    pub fn modified_data_ids(&self) -> Vec<IdentifierWrapper> {
+        let ids = self.0.modified_data_ids();
 
         ids.into_iter().map(IdentifierWrapper::from).collect()
     }
@@ -343,17 +342,25 @@ impl IdentityCreateTransitionWasm {
             BlsAdapter(JsValue::undefined().into())
         };
 
-        self.0
+        // TODO: not the best approach because it involves cloning the transition
+        // Probably it worth to return `sign_by_private_key` per state transition
+        let mut wrapper = StateTransition::IdentityCreate(self.0.clone());
+        wrapper
             .sign_by_private_key(private_key.as_slice(), key_type, &bls_adapter)
-            .with_js_error()
+            .with_js_error()?;
+
+        self.0.set_signature(wrapper.signature().to_owned());
+
+        Ok(())
     }
 
     #[wasm_bindgen(js_name=getSignature)]
     pub fn get_signature(&self) -> Buffer {
-        Buffer::from_bytes_owned(self.0.get_signature().to_vec())
+        Buffer::from_bytes_owned(self.0.signature().to_vec())
     }
     #[wasm_bindgen(js_name=setSignature)]
     pub fn set_signature(&mut self, signature: Option<Vec<u8>>) {
-        self.0.signature = BinaryData::new(signature.unwrap_or(vec![]))
+        self.0
+            .set_signature(BinaryData::new(signature.unwrap_or(vec![])))
     }
 }

package/src/identity/state_transition/identity_create_transition/identity_create_transition_basic_validator.rs

@@ -7,7 +7,6 @@ use dpp::identity::state_transition::validate_public_key_signatures::PublicKeysS
 use dpp::identity::validation::{
     PublicKeysValidator, RequiredPurposeAndSecurityLevelValidator, PUBLIC_KEY_SCHEMA_FOR_TRANSITION,
 };
-use dpp::state_transition::state_transition_execution_context::StateTransitionExecutionContext;
 
 use dpp::version::{ProtocolVersionValidator, COMPATIBILITY_MAP, LATEST_VERSION};
 use dpp::ProtocolError;

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

@@ -1,8 +1,8 @@
 pub use identity_create_transition::*;
 
-pub mod apply_identity_create_transition;
+// pub mod apply_identity_create_transition;
 pub mod identity_create_transition;
-pub mod identity_create_transition_basic_validator;
-pub mod identity_create_transition_state_validator;
+// pub mod identity_create_transition_basic_validator;
+// pub mod identity_create_transition_state_validator;
 
 mod to_object;

package/src/identity/state_transition/identity_create_transition/to_object.rs

@@ -1,8 +1,9 @@
 use dpp::identity::state_transition::asset_lock_proof::AssetLockProof;
-use dpp::identity::state_transition::identity_public_key_transitions::IdentityPublicKeyInCreationWithWitness;
+use dpp::identity::state_transition::AssetLockProved;
+use dpp::state_transition::identity_create_transition::accessors::IdentityCreateTransitionAccessorsV0;
+use dpp::state_transition::public_key_in_creation::IdentityPublicKeyInCreation;
 use dpp::{
-    identifier::Identifier,
-    identity::state_transition::identity_create_transition::IdentityCreateTransition,
+    identifier::Identifier, state_transition::identity_create_transition::IdentityCreateTransition,
     state_transition::StateTransitionLike,
 };
 use serde::Deserialize;
@@ -17,28 +18,26 @@ pub struct ToObjectOptions {
 #[derive(Default)]
 pub struct ToObject {
     pub transition_type: u8,
-    pub protocol_version: u32,
     pub identity_id: Identifier,
     pub asset_lock_proof: AssetLockProof,
-    pub public_keys: Vec<IdentityPublicKeyInCreationWithWitness>,
+    pub public_keys: Vec<IdentityPublicKeyInCreation>,
     pub signature: Option<Vec<u8>>,
 }
 
 pub fn to_object_struct(
     transition: &IdentityCreateTransition,
-    options: ToObjectOptions,
+    options: &ToObjectOptions,
 ) -> ToObject {
     let mut to_object = ToObject {
-        transition_type: transition.get_type() as u8,
-        protocol_version: transition.get_protocol_version(),
-        public_keys: transition.get_public_keys().to_owned(),
-        asset_lock_proof: transition.get_asset_lock_proof().to_owned(),
-        identity_id: transition.get_identity_id().to_owned(),
+        transition_type: transition.state_transition_type() as u8,
+        public_keys: transition.public_keys().to_owned(),
+        asset_lock_proof: transition.asset_lock_proof().to_owned(),
+        identity_id: transition.identity_id().to_owned(),
         signature: None,
     };
 
     if !options.skip_signature.unwrap_or(false) {
-        to_object.signature = Some(transition.get_signature().to_vec());
+        to_object.signature = Some(transition.signature().to_vec());
     }
 
     to_object