feat(wasm-dpp): implement identity create transition

packages/rs-dpp/src/data_trigger/reward_share_data_triggers/mod.rs

@@ -21,7 +21,7 @@ const MAX_DOCUMENTS: usize = 16;
 pub async fn create_masternode_reward_shares_data_trigger<'a, SR>(
     document_transition: &DocumentTransition,
     context: &DataTriggerExecutionContext<'a, SR>,
-    _top_level_identity: Option<&Identifier>,
+    _top_level_identifier: Option<&Identifier>,
 ) -> Result<DataTriggerExecutionResult, anyhow::Error>
 where
     SR: StateRepositoryLike,
@@ -70,15 +70,15 @@ where
 
     // payToId identity exists
     let pay_to_identifier = Identifier::from_bytes(&pay_to_id_bytes)?;
-    let maybe_identifier: Option<Vec<u8>> = context
+    let maybe_identity = context
         .state_repository
         .fetch_identity(
             &pay_to_identifier,
             context.state_transition_execution_context,
         )
         .await?;
 
-    if !is_dry_run && maybe_identifier.is_none() {
+    if !is_dry_run && maybe_identity.is_none() {
         let err = create_error(
             context,
             dt_create,
@@ -139,6 +139,7 @@ mod test {
     use itertools::Itertools;
     use serde_json::json;
 
+    use crate::identity::Identity;
     use crate::{
         data_contract::DataContract,
         data_trigger::DataTriggerExecutionContext,
@@ -160,22 +161,23 @@ mod test {
     };
 
     struct TestData {
-        top_level_identity: Identifier,
+        top_level_identifier: Identifier,
         data_contract: DataContract,
         sml_store: SMLStore,
         documents: Vec<Document>,
         document_transition: DocumentTransition,
+        identity: Identity,
     }
 
     fn setup_test() -> TestData {
-        let top_level_identity_hex =
+        let top_level_identifier_hex =
             "c286807d463b06c7aba3b9a60acf64c1fc03da8c1422005cd9b4293f08cf0562";
-        let top_level_identity =
-            Identifier::from_bytes(&hex::decode(top_level_identity_hex).unwrap()).unwrap();
+        let top_level_identifier =
+            Identifier::from_bytes(&hex::decode(top_level_identifier_hex).unwrap()).unwrap();
 
         let sml_entries: Vec<SMLEntry> = vec![
             SMLEntry {
-          pro_reg_tx_hash: top_level_identity_hex.to_string(),
+          pro_reg_tx_hash: top_level_identifier_hex.to_string(),
           confirmed_hash: "4eb56228c535db3b234907113fd41d57bcc7cdcb8e0e00e57590af27ee88c119".to_string(),
           service: "192.168.65.2:20101".to_string(),
           pub_key_operator: "809519c5f6f3be1c08782ac42ae9a83b6c7205eba43f9a96a4f032ec7a73f1a7c25fa78cce0d6d9c135f7e2c28527179".to_string(),
@@ -208,9 +210,10 @@ mod test {
         TestData {
             documents,
             data_contract,
-            top_level_identity,
+            top_level_identifier,
             sml_store,
             document_transition: document_transitions[0].clone(),
+            identity: Identity::default(),
         }
     }
 
@@ -238,7 +241,7 @@ mod test {
             documents,
             sml_store,
             data_contract,
-            top_level_identity,
+            top_level_identifier,
             ..
         } = setup_test();
 
@@ -247,7 +250,7 @@ mod test {
             .expect_fetch_sml_store()
             .returning(move || Ok(sml_store.clone()));
         state_repository_mock
-            .expect_fetch_identity::<Vec<u8>>()
+            .expect_fetch_identity()
             .returning(|_, _| Ok(None));
         state_repository_mock
             .expect_fetch_documents()
@@ -259,7 +262,7 @@ mod test {
         let execution_context = StateTransitionExecutionContext::default();
         let context = DataTriggerExecutionContext {
             data_contract: &data_contract,
-            owner_id: &top_level_identity,
+            owner_id: &top_level_identifier,
             state_repository: &state_repository_mock,
             state_transition_execution_context: &execution_context,
         };
@@ -281,7 +284,7 @@ mod test {
             document_transition,
             sml_store,
             data_contract,
-            top_level_identity,
+            top_level_identifier,
             ..
         } = setup_test();
 
@@ -290,7 +293,7 @@ mod test {
             .expect_fetch_sml_store()
             .returning(move || Ok(sml_store.clone()));
         state_repository_mock
-            .expect_fetch_identity::<Vec<u8>>()
+            .expect_fetch_identity()
             .returning(move |_, _| Ok(None));
         state_repository_mock
             .expect_fetch_documents::<Document>()
@@ -299,7 +302,7 @@ mod test {
         let execution_context = StateTransitionExecutionContext::default();
         let context = DataTriggerExecutionContext {
             data_contract: &data_contract,
-            owner_id: &top_level_identity,
+            owner_id: &top_level_identifier,
             state_repository: &state_repository_mock,
             state_transition_execution_context: &execution_context,
         };
@@ -338,7 +341,7 @@ mod test {
             .expect_fetch_sml_store()
             .returning(move || Ok(sml_store.clone()));
         state_repository_mock
-            .expect_fetch_identity::<Vec<u8>>()
+            .expect_fetch_identity()
             .returning(move |_, _| Ok(None));
         state_repository_mock
             .expect_fetch_documents::<Document>()
@@ -368,26 +371,26 @@ mod test {
             document_transition,
             sml_store,
             data_contract,
-            top_level_identity,
+            top_level_identifier,
+            identity,
             ..
         } = setup_test();
 
         let mut state_repository_mock = MockStateRepositoryLike::new();
-        let identity_to_return = top_level_identity.as_bytes().to_vec();
         state_repository_mock
             .expect_fetch_sml_store()
             .returning(move || Ok(sml_store.clone()));
         state_repository_mock
-            .expect_fetch_identity::<Vec<u8>>()
-            .returning(move |_, _| Ok(Some(identity_to_return.clone())));
+            .expect_fetch_identity()
+            .returning(move |_, _| Ok(Some(identity.clone())));
         state_repository_mock
             .expect_fetch_documents::<Document>()
             .returning(move |_, _, _, _| Ok(vec![]));
 
         let execution_context = StateTransitionExecutionContext::default();
         let context = DataTriggerExecutionContext {
             data_contract: &data_contract,
-            owner_id: &top_level_identity,
+            owner_id: &top_level_identifier,
             state_repository: &state_repository_mock,
             state_transition_execution_context: &execution_context,
         };
@@ -404,18 +407,18 @@ mod test {
             document_transition,
             sml_store,
             data_contract,
-            top_level_identity,
+            top_level_identifier,
+            identity,
             ..
         } = setup_test();
 
         let mut state_repository_mock = MockStateRepositoryLike::new();
-        let identity_to_return = top_level_identity.as_bytes().to_vec();
         state_repository_mock
             .expect_fetch_sml_store()
             .returning(move || Ok(sml_store.clone()));
         state_repository_mock
-            .expect_fetch_identity::<Vec<u8>>()
-            .returning(move |_, _| Ok(Some(identity_to_return.clone())));
+            .expect_fetch_identity()
+            .returning(move |_, _| Ok(Some(identity.clone())));
         let documents_to_return: Vec<Document> = (0..16).map(|_| Document::default()).collect();
         state_repository_mock
             .expect_fetch_documents::<Document>()
@@ -424,7 +427,7 @@ mod test {
         let execution_context = StateTransitionExecutionContext::default();
         let context = DataTriggerExecutionContext {
             data_contract: &data_contract,
-            owner_id: &top_level_identity,
+            owner_id: &top_level_identifier,
             state_repository: &state_repository_mock,
             state_transition_execution_context: &execution_context,
         };
@@ -445,13 +448,13 @@ mod test {
         let TestData {
             document_transition,
             data_contract,
-            top_level_identity,
+            top_level_identifier,
             ..
         } = setup_test();
 
         let mut state_repository_mock = MockStateRepositoryLike::new();
         state_repository_mock
-            .expect_fetch_identity::<Vec<u8>>()
+            .expect_fetch_identity()
             .returning(move |_, _| Ok(None));
         state_repository_mock
             .expect_fetch_documents::<Document>()
@@ -462,7 +465,7 @@ mod test {
 
         let context = DataTriggerExecutionContext {
             data_contract: &data_contract,
-            owner_id: &top_level_identity,
+            owner_id: &top_level_identifier,
             state_repository: &state_repository_mock,
             state_transition_execution_context: &execution_context,
         };

packages/rs-dpp/src/errors/consensus/basic/identity/invalid_asset_lock_proof_transaction_height_error.rs

@@ -21,7 +21,7 @@ impl InvalidAssetLockProofTransactionHeightError {
         self.proof_core_chain_locked_height
     }
 
-    pub fn current_core_chain_locked_height(&self) -> Option<u32> {
+    pub fn transaction_height(&self) -> Option<u32> {
         self.transaction_height
     }
 }

packages/rs-dpp/src/errors/errors.rs

@@ -106,6 +106,9 @@ pub enum ProtocolError {
 
     #[error("Public key is disabled")]
     PublicKeyIsDisabledError { public_key: IdentityPublicKey },
+
+    #[error("Identity is not present")]
+    IdentityNotPresentError { id: Identifier },
 }
 
 impl From<NonConsensusError> for ProtocolError {

packages/rs-dpp/src/errors/non_consensus_error.rs

@@ -4,7 +4,7 @@ use crate::{
     CompatibleProtocolVersionIsNotDefinedError, InvalidVectorSizeError, SerdeParsingError,
 };
 
-#[derive(Debug, Error, Clone)]
+#[derive(Debug, Error)]
 pub enum NonConsensusError {
     #[error("Unexpected serde parsing error: {0:#}")]
     SerdeParsingError(SerdeParsingError),
@@ -34,6 +34,9 @@ pub enum NonConsensusError {
         object_name: &'static str,
         details: String,
     },
+
+    #[error(transparent)]
+    Error(#[from] anyhow::Error),
 }
 
 pub mod object_names {

packages/rs-dpp/src/identity/errors/unknown_asset_lock_proof_type_error.rs

@@ -3,15 +3,15 @@ use thiserror::Error;
 #[derive(Error, Debug, Clone, PartialEq, Eq)]
 #[error("'Unknown Asset lock proof type'")]
 pub struct UnknownAssetLockProofTypeError {
-    asset_lock_type: u32,
+    asset_lock_type: Option<u8>,
 }
 
 impl UnknownAssetLockProofTypeError {
-    pub fn new(asset_lock_type: u32) -> Self {
+    pub fn new(asset_lock_type: Option<u8>) -> Self {
         Self { asset_lock_type }
     }
 
-    pub fn asset_lock_type(&self) -> u32 {
+    pub fn asset_lock_type(&self) -> Option<u8> {
         self.asset_lock_type
     }
 }

packages/rs-dpp/src/identity/state_transition/asset_lock_proof/asset_lock_transaction_output_fetcher.rs

@@ -1,3 +1,4 @@
+use std::convert::TryInto;
 use std::sync::Arc;
 
 use dashcore::hashes::hex::ToHex;
@@ -50,8 +51,8 @@ pub async fn fetch_asset_lock_transaction_output(
             let output_index = out_point.vout as usize;
             let transaction_hash = out_point.txid;
 
-            let maybe_raw_transaction = state_repository
-                .fetch_transaction::<Vec<u8>>(&transaction_hash.to_hex(), execution_context)
+            let transaction_data = state_repository
+                .fetch_transaction(&transaction_hash.to_hex(), execution_context)
                 .await
                 .map_err(|_| DPPError::InvalidAssetLockTransaction)?;
 
@@ -62,9 +63,14 @@ pub async fn fetch_asset_lock_transaction_output(
                 });
             }
 
-            if let Some(raw_transaction) = maybe_raw_transaction {
+            let transaction_data = transaction_data
+                .try_into()
+                .map_err(|_| DPPError::InvalidAssetLockTransaction)?;
+
+            if let Some(raw_transaction) = transaction_data.data {
                 let transaction = Transaction::deserialize(&raw_transaction)
                     .map_err(|_| DPPError::InvalidAssetLockTransaction)?;
+
                 transaction
                     .output
                     .get(output_index)
@@ -81,6 +87,7 @@ pub async fn fetch_asset_lock_transaction_output(
 
 #[cfg(test)]
 mod test {
+    use crate::state_repository::FetchTransactionResponse;
     use crate::{
         identity::state_transition::asset_lock_proof::chain::ChainAssetLockProof,
         state_repository::MockStateRepositoryLike,
@@ -95,8 +102,8 @@ mod test {
         let execution_context = StateTransitionExecutionContext::default();
 
         state_repository_mock
-            .expect_fetch_transaction::<Vec<u8>>()
-            .return_once(|_, _| Ok(None));
+            .expect_fetch_transaction()
+            .return_once(|_, _| Ok(FetchTransactionResponse::default()));
         execution_context.enable_dry_run();
 
         let result = fetch_asset_lock_transaction_output(

packages/rs-dpp/src/identity/state_transition/asset_lock_proof/asset_lock_transaction_validator.rs

@@ -83,7 +83,9 @@ where
                     }
 
                     let out_point = OutPoint::new(transaction.txid(), output_index as u32);
-                    let out_point_buf = consensus::serialize(&out_point);
+                    let mut out_point_buf = consensus::serialize(&out_point);
+                    let (tx_id, _) = out_point_buf.split_at_mut(32);
+                    tx_id.reverse();
 
                     let is_out_point_used = self
                         .state_repository

packages/rs-dpp/src/identity/state_transition/asset_lock_proof/chain/chain_asset_lock_proof.rs

@@ -1,11 +1,12 @@
 use serde::{Deserialize, Serialize};
 use serde_big_array::BigArray;
 
-use crate::identifier::Identifier;
-use crate::util::hash::hash;
-use crate::util::vec::vec_to_array;
+use crate::{
+    errors::NonConsensusError, identifier::Identifier, util::hash::hash, util::vec::vec_to_array,
+};
 
 #[derive(Clone, PartialEq, Eq, Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
 pub struct ChainAssetLockProof {
     #[serde(rename = "type")]
     asset_lock_type: u8,
@@ -34,16 +35,22 @@ impl ChainAssetLockProof {
         self.core_chain_locked_height
     }
 
+    pub fn set_core_chain_locked_height(&mut self, value: u32) {
+        self.core_chain_locked_height = value;
+    }
+
     /// Get out_point
     pub fn out_point(&self) -> &[u8; 36] {
         &self.out_point
     }
 
+    pub fn set_out_point(&mut self, out_point: [u8; 36]) {
+        self.out_point = out_point;
+    }
+
     /// Create identifier
-    pub fn create_identifier(&self) -> Identifier {
-        return Identifier::new(
-            vec_to_array(hash(self.out_point()).as_ref())
-                .expect("Expected hash function to give a 32 byte output"),
-        );
+    pub fn create_identifier(&self) -> Result<Identifier, NonConsensusError> {
+        let array = vec_to_array(hash(self.out_point).as_ref())?;
+        Ok(Identifier::new(array))
     }
 }