refactor: preserve typed SdkError in TaskError variants for duplicate-key errors (#731)

* Initial plan

* fix: log raw SdkError in broadcast_error to preserve technical context

Co-authored-by: lklimek <842586+lklimek@users.noreply.github.com>

* refactor: embed raw SdkError as source_error field in typed TaskError variants

Co-authored-by: lklimek <842586+lklimek@users.noreply.github.com>

* refactor: store Box<SdkError> as typed source in TaskError variants instead of debug string

Co-authored-by: lklimek <842586+lklimek@users.noreply.github.com>

* style: fix rustfmt formatting issues in error.rs and add_key_to_identity.rs

Co-authored-by: lklimek <842586+lklimek@users.noreply.github.com>

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: lklimek <842586+lklimek@users.noreply.github.com>

Author: Copilot

src/backend_task/error.rs

@@ -5,6 +5,7 @@
 //! `From<String>` → backwards compatible with existing `Result<T, String>` code.
 //!   Parses known error patterns into typed variants automatically.
 
+use dash_sdk::Error as SdkError;
 use dash_sdk::dashcore_rpc;
 use thiserror::Error;
 
@@ -63,17 +64,30 @@ pub enum TaskError {
 
     /// Duplicate identity public key — the key data already exists on the platform.
     #[error("This public key is already registered on the platform. Try a different key.")]
-    DuplicateIdentityPublicKey,
+    DuplicateIdentityPublicKey {
+        /// The original SDK error returned by the broadcast API.
+        #[source]
+        source_error: Box<SdkError>,
+    },
 
     /// Duplicate identity public key ID — the key hash is already taken platform-wide.
     #[error("This key hash is already registered on the platform. Try a different key.")]
-    DuplicateIdentityPublicKeyId,
+    DuplicateIdentityPublicKeyId {
+        /// The original SDK error returned by the broadcast API.
+        #[source]
+        source_error: Box<SdkError>,
+    },
 
     /// Identity public key conflicts with an existing key's unique contract bounds.
     #[error(
         "This key conflicts with an existing key bound to contract {contract_id}. Use a different key or purpose."
     )]
-    IdentityPublicKeyContractBoundsConflict { contract_id: String },
+    IdentityPublicKeyContractBoundsConflict {
+        contract_id: String,
+        /// The original SDK error returned by the broadcast API.
+        #[source]
+        source_error: Box<SdkError>,
+    },
 }
 
 impl From<String> for TaskError {

src/backend_task/identity/add_key_to_identity.rs

@@ -28,33 +28,55 @@ use dash_sdk::platform::{Fetch, Identity};
 /// 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()),
-        _ => None,
-    };
+/// The original `SdkError` is preserved as a typed field on each variant.
+fn broadcast_error(error: SdkError) -> TaskError {
+    // Classify the error while borrowing; the borrow is dropped before `error`
+    // is moved into the returned variant.
+    enum ConsensusKind {
+        DuplicateKey,
+        DuplicateKeyId,
+        ContractBoundsConflict(String),
+    }
+
+    let kind: Option<ConsensusKind> = {
+        let consensus_error = match &error {
+            SdkError::StateTransitionBroadcastError(broadcast_err) => broadcast_err.cause.as_ref(),
+            SdkError::Protocol(ProtocolError::ConsensusError(ce)) => Some(ce.as_ref()),
+            _ => None,
+        };
 
-    if let Some(ce) = consensus_error {
-        match ce {
+        consensus_error.and_then(|ce| match ce {
             ConsensusError::StateError(StateError::DuplicatedIdentityPublicKeyStateError(_)) => {
-                return TaskError::DuplicateIdentityPublicKey;
+                Some(ConsensusKind::DuplicateKey)
             }
             ConsensusError::StateError(StateError::DuplicatedIdentityPublicKeyIdStateError(_)) => {
-                return TaskError::DuplicateIdentityPublicKeyId;
+                Some(ConsensusKind::DuplicateKeyId)
             }
             ConsensusError::StateError(
                 StateError::IdentityPublicKeyAlreadyExistsForUniqueContractBoundsError(e),
-            ) => {
-                return TaskError::IdentityPublicKeyContractBoundsConflict {
-                    contract_id: e.contract_id().to_string(Encoding::Base58),
-                };
+            ) => Some(ConsensusKind::ContractBoundsConflict(
+                e.contract_id().to_string(Encoding::Base58),
+            )),
+            _ => None,
+        })
+    };
+
+    let boxed = Box::new(error);
+    match kind {
+        Some(ConsensusKind::DuplicateKey) => TaskError::DuplicateIdentityPublicKey {
+            source_error: boxed,
+        },
+        Some(ConsensusKind::DuplicateKeyId) => TaskError::DuplicateIdentityPublicKeyId {
+            source_error: boxed,
+        },
+        Some(ConsensusKind::ContractBoundsConflict(contract_id)) => {
+            TaskError::IdentityPublicKeyContractBoundsConflict {
+                contract_id,
+                source_error: boxed,
             }
-            _ => {}
         }
+        None => TaskError::Generic(format!("Broadcasting error: {boxed}")),
     }
-
-    TaskError::Generic(format!("Broadcasting error: {}", error))
 }
 
 impl AppContext {
@@ -109,7 +131,7 @@ impl AppContext {
         let result = state_transition
             .broadcast_and_wait(sdk, None)
             .await
-            .map_err(|ref e| broadcast_error(e))?;
+            .map_err(broadcast_error)?;
 
         // Log and handle the proof result
         tracing::info!("AddKeyToIdentity proof result: {}", result);
@@ -181,16 +203,19 @@ mod tests {
         let consensus =
             ConsensusError::from(DuplicatedIdentityPublicKeyStateError::new(vec![1, 2]));
         let sdk_err = SdkError::from(consensus);
-        let err = broadcast_error(&sdk_err);
-        assert!(matches!(err, TaskError::DuplicateIdentityPublicKey));
+        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 err = broadcast_error(&sdk_err);
-        assert!(matches!(err, TaskError::DuplicateIdentityPublicKeyId));
+        let err = broadcast_error(sdk_err);
+        assert!(matches!(
+            err,
+            TaskError::DuplicateIdentityPublicKeyId { .. }
+        ));
     }
 
     #[test]
@@ -207,10 +232,10 @@ mod tests {
             ),
         );
         let sdk_err = SdkError::from(consensus);
-        let err = broadcast_error(&sdk_err);
+        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)
+            matches!(err, TaskError::IdentityPublicKeyContractBoundsConflict { ref contract_id, .. } if *contract_id == expected_contract_id)
         );
     }
 
@@ -225,14 +250,14 @@ mod tests {
             cause: Some(consensus),
         };
         let sdk_err = SdkError::StateTransitionBroadcastError(broadcast_err);
-        let err = broadcast_error(&sdk_err);
-        assert!(matches!(err, TaskError::DuplicateIdentityPublicKey));
+        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 err = broadcast_error(&sdk_err);
+        let err = broadcast_error(sdk_err);
         assert!(matches!(err, TaskError::Generic(ref s) if s.contains("connection timeout")));
     }
 }