refactor: return typed TaskError from identity backend tasks

src/backend_task/identity/add_key_to_identity.rs

@@ -15,14 +15,20 @@ use dash_sdk::dpp::identity::accessors::{IdentityGettersV0, IdentitySettersV0};
 use dash_sdk::dpp::identity::identity_public_key::accessors::v0::{
     IdentityPublicKeyGettersV0, IdentityPublicKeySettersV0,
 };
+use dash_sdk::dpp::platform_value::string_encoding::Encoding;
 use dash_sdk::dpp::prelude::UserFeeIncrease;
 use dash_sdk::dpp::state_transition::identity_update_transition::IdentityUpdateTransition;
 use dash_sdk::dpp::state_transition::identity_update_transition::methods::IdentityUpdateTransitionMethodsV0;
 use dash_sdk::dpp::state_transition::proof_result::StateTransitionProofResult;
 use dash_sdk::platform::transition::broadcast::BroadcastStateTransition;
 use dash_sdk::platform::{Fetch, Identity};
 
-fn broadcast_error_message(error: &SdkError) -> String {
+/// Converts a broadcast SDK error into a typed `TaskError`.
+///
+/// Matches known consensus error variants from two SDK error paths
+/// (`StateTransitionBroadcastError` and `Protocol/ConsensusError`),
+/// falling back to `TaskError::Generic` for unrecognised errors.
+fn broadcast_error(error: &SdkError) -> TaskError {
     let consensus_error = match error {
         SdkError::StateTransitionBroadcastError(broadcast_err) => broadcast_err.cause.as_ref(),
         SdkError::Protocol(ProtocolError::ConsensusError(ce)) => Some(ce.as_ref()),
@@ -32,24 +38,23 @@ fn broadcast_error_message(error: &SdkError) -> String {
     if let Some(ce) = consensus_error {
         match ce {
             ConsensusError::StateError(StateError::DuplicatedIdentityPublicKeyStateError(_)) => {
-                return TaskError::DuplicateIdentityPublicKey.to_string();
+                return TaskError::DuplicateIdentityPublicKey;
             }
             ConsensusError::StateError(StateError::DuplicatedIdentityPublicKeyIdStateError(_)) => {
-                return TaskError::DuplicateIdentityPublicKeyId.to_string();
+                return TaskError::DuplicateIdentityPublicKeyId;
             }
             ConsensusError::StateError(
                 StateError::IdentityPublicKeyAlreadyExistsForUniqueContractBoundsError(e),
             ) => {
                 return TaskError::IdentityPublicKeyContractBoundsConflict {
-                    contract_id: format!("{}", e.contract_id()),
-                }
-                .to_string();
+                    contract_id: e.contract_id().to_string(Encoding::Base58),
+                };
             }
             _ => {}
         }
     }
 
-    format!("Broadcasting error: {}", error)
+    TaskError::Generic(format!("Broadcasting error: {}", error))
 }
 
 impl AppContext {
@@ -59,19 +64,19 @@ impl AppContext {
         mut qualified_identity: QualifiedIdentity,
         mut public_key_to_add: QualifiedIdentityPublicKey,
         private_key: [u8; 32],
-    ) -> Result<BackendTaskSuccessResult, String> {
+    ) -> Result<BackendTaskSuccessResult, TaskError> {
         let new_identity_nonce = sdk
             .get_identity_nonce(qualified_identity.identity.id(), true, None)
             .await
             .map_err(|e| format!("Fetch nonce error: {}", e))?;
         let Some(master_key) = qualified_identity.can_sign_with_master_key() else {
-            return Err("Master key not found".to_string());
+            return Err("Master key not found".to_string().into());
         };
         let master_key_id = master_key.identity_public_key.id();
         let identity = Identity::fetch_by_identifier(sdk, qualified_identity.identity.id())
             .await
-            .map_err(|e| format!("Fetch nonce error: {}", e))?
-            .ok_or("Identity not found".to_string())?;
+            .map_err(|e| format!("Fetch identity error: {}", e))?
+            .ok_or_else(|| TaskError::Generic("Identity not found".into()))?;
         qualified_identity.identity = identity;
         qualified_identity.identity.bump_revision();
         public_key_to_add
@@ -104,7 +109,7 @@ impl AppContext {
         let result = state_transition
             .broadcast_and_wait(sdk, None)
             .await
-            .map_err(|ref e| broadcast_error_message(e))?;
+            .map_err(|ref e| broadcast_error(e))?;
 
         // Log and handle the proof result
         tracing::info!("AddKeyToIdentity proof result: {}", result);
@@ -158,7 +163,7 @@ impl AppContext {
 
         self.update_local_qualified_identity(&qualified_identity)
             .map(|_| BackendTaskSuccessResult::AddedKeyToIdentity(fee_result))
-            .map_err(|e| format!("Database error: {}", e))
+            .map_err(|e| TaskError::Generic(format!("Database error: {}", e)))
     }
 }
 
@@ -176,22 +181,16 @@ mod tests {
         let consensus =
             ConsensusError::from(DuplicatedIdentityPublicKeyStateError::new(vec![1, 2]));
         let sdk_err = SdkError::from(consensus);
-        let msg = broadcast_error_message(&sdk_err);
-        assert_eq!(
-            msg,
-            "This public key is already registered on the platform. Try a different key."
-        );
+        let err = broadcast_error(&sdk_err);
+        assert!(matches!(err, TaskError::DuplicateIdentityPublicKey));
     }
 
     #[test]
     fn test_duplicate_public_key_id_error() {
         let consensus = ConsensusError::from(DuplicatedIdentityPublicKeyIdStateError::new(vec![3]));
         let sdk_err = SdkError::from(consensus);
-        let msg = broadcast_error_message(&sdk_err);
-        assert_eq!(
-            msg,
-            "This key hash is already registered on the platform. Try a different key."
-        );
+        let err = broadcast_error(&sdk_err);
+        assert!(matches!(err, TaskError::DuplicateIdentityPublicKeyId));
     }
 
     #[test]
@@ -208,13 +207,10 @@ mod tests {
             ),
         );
         let sdk_err = SdkError::from(consensus);
-        let msg = broadcast_error_message(&sdk_err);
-        assert_eq!(
-            msg,
-            format!(
-                "This key conflicts with an existing key bound to contract {}. Use a different key or purpose.",
-                contract_id
-            )
+        let err = broadcast_error(&sdk_err);
+        let expected_contract_id = contract_id.to_string(Encoding::Base58);
+        assert!(
+            matches!(err, TaskError::IdentityPublicKeyContractBoundsConflict { ref contract_id } if *contract_id == expected_contract_id)
         );
     }
 
@@ -229,18 +225,14 @@ mod tests {
             cause: Some(consensus),
         };
         let sdk_err = SdkError::StateTransitionBroadcastError(broadcast_err);
-        let msg = broadcast_error_message(&sdk_err);
-        assert_eq!(
-            msg,
-            "This public key is already registered on the platform. Try a different key."
-        );
+        let err = broadcast_error(&sdk_err);
+        assert!(matches!(err, TaskError::DuplicateIdentityPublicKey));
     }
 
     #[test]
     fn test_unknown_sdk_error_falls_back() {
         let sdk_err = SdkError::Generic("connection timeout".to_string());
-        let msg = broadcast_error_message(&sdk_err);
-        assert!(msg.starts_with("Broadcasting error:"));
-        assert!(msg.contains("connection timeout"));
+        let err = broadcast_error(&sdk_err);
+        assert!(matches!(err, TaskError::Generic(ref s) if s.contains("connection timeout")));
     }
 }

src/backend_task/identity/mod.rs

@@ -11,7 +11,7 @@ mod top_up_identity;
 mod transfer;
 mod withdraw_from_identity;
 
-use super::{BackendTaskSuccessResult, FeeResult};
+use super::{BackendTaskSuccessResult, FeeResult, TaskError};
 use crate::app::TaskResult;
 use crate::context::AppContext;
 use crate::model::qualified_identity::encrypted_key_storage::{KeyStorage, WalletDerivationPath};
@@ -530,65 +530,59 @@ impl AppContext {
         task: IdentityTask,
         sdk: &Sdk,
         sender: crate::utils::egui_mpsc::SenderAsync<TaskResult>,
-    ) -> Result<BackendTaskSuccessResult, String> {
+    ) -> Result<BackendTaskSuccessResult, TaskError> {
         match task {
-            IdentityTask::LoadIdentity(input) => self.load_identity(sdk, input).await,
+            IdentityTask::LoadIdentity(input) => Ok(self.load_identity(sdk, input).await?),
             IdentityTask::WithdrawFromIdentity(qualified_identity, to_address, credits, id) => {
-                self.withdraw_from_identity(qualified_identity, to_address, credits, id)
-                    .await
+                Ok(self
+                    .withdraw_from_identity(qualified_identity, to_address, credits, id)
+                    .await?)
             }
             IdentityTask::AddKeyToIdentity(qualified_identity, public_key_to_add, private_key) => {
                 self.add_key_to_identity(sdk, qualified_identity, public_key_to_add, private_key)
                     .await
             }
             IdentityTask::RegisterIdentity(registration_info) => {
-                self.register_identity(registration_info).await
+                Ok(self.register_identity(registration_info).await?)
             }
-            IdentityTask::RegisterDpnsName(input) => self.register_dpns_name(sdk, input).await,
-            IdentityTask::RefreshIdentity(qualified_identity) => self
+            IdentityTask::RegisterDpnsName(input) => {
+                Ok(self.register_dpns_name(sdk, input).await?)
+            }
+            IdentityTask::RefreshIdentity(qualified_identity) => Ok(self
                 .refresh_identity(sdk, qualified_identity, sender)
                 .await
-                .map_err(|e| format!("Error refreshing identity: {}", e)),
-            IdentityTask::Transfer(qualified_identity, to_identifier, credits, id) => {
-                self.transfer_to_identity(qualified_identity, to_identifier, credits, id)
-                    .await
-            }
-            IdentityTask::SearchIdentityFromWallet(wallet, identity_index) => {
-                self.load_user_identity_from_wallet(sdk, wallet, identity_index, sender)
-                    .await
-            }
-            IdentityTask::SearchIdentitiesUpToIndex(wallet, max_identity_index) => {
-                self.load_user_identities_up_to_index(sdk, wallet, max_identity_index, sender)
-                    .await
+                .map_err(|e| format!("Error refreshing identity: {}", e))?),
+            IdentityTask::Transfer(qualified_identity, to_identifier, credits, id) => Ok(self
+                .transfer_to_identity(qualified_identity, to_identifier, credits, id)
+                .await?),
+            IdentityTask::SearchIdentityFromWallet(wallet, identity_index) => Ok(self
+                .load_user_identity_from_wallet(sdk, wallet, identity_index, sender)
+                .await?),
+            IdentityTask::SearchIdentitiesUpToIndex(wallet, max_identity_index) => Ok(self
+                .load_user_identities_up_to_index(sdk, wallet, max_identity_index, sender)
+                .await?),
+            IdentityTask::SearchIdentityByDpnsName(dpns_name, wallet_seed_hash) => Ok(self
+                .load_identity_by_dpns_name(sdk, dpns_name, wallet_seed_hash)
+                .await?),
+            IdentityTask::TopUpIdentity(top_up_info) => {
+                Ok(self.top_up_identity(top_up_info).await?)
             }
-            IdentityTask::SearchIdentityByDpnsName(dpns_name, wallet_seed_hash) => {
-                self.load_identity_by_dpns_name(sdk, dpns_name, wallet_seed_hash)
-                    .await
-            }
-            IdentityTask::TopUpIdentity(top_up_info) => self.top_up_identity(top_up_info).await,
             IdentityTask::TopUpIdentityFromPlatformAddresses {
                 identity,
                 inputs,
                 wallet_seed_hash,
-            } => {
-                self.top_up_identity_from_platform_addresses(
-                    sdk,
-                    identity,
-                    inputs,
-                    wallet_seed_hash,
-                )
-                .await
-            }
+            } => Ok(self
+                .top_up_identity_from_platform_addresses(sdk, identity, inputs, wallet_seed_hash)
+                .await?),
             IdentityTask::TransferToAddresses {
                 identity,
                 outputs,
                 key_id,
-            } => {
-                self.transfer_to_addresses(sdk, identity, outputs, key_id)
-                    .await
-            }
+            } => Ok(self
+                .transfer_to_addresses(sdk, identity, outputs, key_id)
+                .await?),
             IdentityTask::RefreshLoadedIdentitiesOwnedDPNSNames => {
-                self.refresh_loaded_identities_dpns_names(sender).await
+                Ok(self.refresh_loaded_identities_dpns_names(sender).await?)
             }
         }
     }