fix(committor): report shared signature on single-stage finalize failure

magicblock-committor-service/src/intent_executor/error.rs

@@ -129,7 +129,20 @@ impl IntentExecutorError {
             finalize_signature,
         }
     }
+}
+
+/// Maps a single-stage execution failure to [`IntentExecutorError`].
+///
+/// `commit_signature` stays `None` so retry semantics remain unchanged for
+/// transient send failures. The failed transaction signature is still exposed
+/// via [`IntentExecutorError::signatures`].
+pub(crate) fn single_stage_finalize_execution_error(
+    err: TransactionStrategyExecutionError,
+) -> IntentExecutorError {
+    IntentExecutorError::from_finalize_execution_error(err, None)
+}
 
+impl IntentExecutorError {
     /// True when re-executing the whole intent from scratch may succeed:
     /// the failure was transport/RPC-side rather than deterministic.
     /// Once a commit landed (two-stage finalize failures) re-execution would
@@ -168,7 +181,11 @@ impl IntentExecutorError {
                 err: _,
                 commit_signature,
                 finalize_signature,
-            } => commit_signature.map(|el| (el, *finalize_signature)),
+            } => match (*commit_signature, *finalize_signature) {
+                (Some(commit), finalize) => Some((commit, finalize)),
+                (None, Some(finalize)) => Some((finalize, Some(finalize))),
+                _ => None,
+            },
             IntentExecutorError::EmptyIntentError
             | IntentExecutorError::FailedToFitError
             | IntentExecutorError::SignerError(_) => None,
@@ -678,6 +695,43 @@ mod tests {
         assert!(!err.is_transient());
     }
 
+    #[test]
+    fn single_stage_finalize_failure_reports_shared_signature() {
+        let signature = solana_signature::Signature::new_unique();
+        let err = TransactionStrategyExecutionError::InternalError(
+            InternalError::MagicBlockRpcClientError(Box::new(
+                MagicBlockRpcClientError::SentTransactionError(
+                    solana_transaction_error::TransactionError::InstructionError(
+                        0,
+                        solana_instruction::error::InstructionError::Custom(1),
+                    ),
+                    signature,
+                ),
+            )),
+        );
+
+        let wrapped = super::single_stage_finalize_execution_error(err);
+        assert_eq!(wrapped.signatures(), Some((signature, Some(signature))));
+        assert!(!wrapped.is_transient());
+    }
+
+    #[test]
+    fn single_stage_blockhash_not_found_failure_stays_transient() {
+        let signature = solana_signature::Signature::new_unique();
+        let err = TransactionStrategyExecutionError::InternalError(
+            InternalError::MagicBlockRpcClientError(Box::new(
+                MagicBlockRpcClientError::SentTransactionError(
+                    solana_transaction_error::TransactionError::BlockhashNotFound,
+                    signature,
+                ),
+            )),
+        );
+
+        let wrapped = super::single_stage_finalize_execution_error(err);
+        assert_eq!(wrapped.signatures(), Some((signature, Some(signature))));
+        assert!(wrapped.is_transient());
+    }
+
     #[test]
     fn unrelated_internal_errors_do_not_trigger_single_stage_split() {
         let err = TransactionStrategyExecutionError::InternalError(

magicblock-committor-service/src/intent_executor/single_stage_executor.rs

@@ -10,8 +10,8 @@ use tracing::{error, instrument};
 use crate::{
     intent_executor::{
         error::{
-            IntentExecutorError, IntentExecutorResult,
-            TransactionStrategyExecutionError,
+            single_stage_finalize_execution_error, IntentExecutorError,
+            IntentExecutorResult, TransactionStrategyExecutionError,
         },
         intent_execution_client::IntentExecutionClient,
         task_info_fetcher::{CacheTaskInfoFetcher, TaskInfoFetcher},
@@ -133,13 +133,7 @@ where
             }
         };
 
-        result.map_err(|err| {
-            IntentExecutorError::from_finalize_execution_error(
-                err,
-                // TODO(edwin): shall one stage have same signature for commit & finalize
-                None,
-            )
-        })
+        result.map_err(single_stage_finalize_execution_error)
     }
 
     pub fn has_callbacks(&self) -> bool {