[mfp] allow partial failures in soft bundles (#23910)

## Description 

Soft bundles can include transactions from multiple sources. Permitting
partial failure seems necessary, where some transactions may fail
without invalidating the entire request. Otherwise, a single source
submitting invalid transactions can deterministically cause the bundle
request to fail.

When partial failures are allowed, each transaction must handle the
situations in which some transactions in the bundle have been rejected
or already executed at submission. This is the case in existing soft
bundle usages pre-MFP.

## Test plan 

CI

Author: mwtian

crates/sui-core/src/authority_server.rs

@@ -628,6 +628,10 @@ impl ValidatorService {
             );
         }
 
+        // NOTE: for soft bundle requests, the system tries to sequence the transactions in the same order
+        // if they use the same gas price. But this is only done with best effort.
+        // Transactions in a soft bundle can be individually rejected or deferred, without affecting
+        // other transactions in the same bundle.
         let is_soft_bundle_request = submit_type == SubmitTxType::SoftBundle;
 
         let max_num_transactions = if is_soft_bundle_request {
@@ -701,10 +705,6 @@ impl ValidatorService {
                     .num_rejected_tx_during_overload
                     .with_label_values(&[error.as_ref()])
                     .inc();
-                // Avoid breaking the soft bundle if one transaction is rejected.
-                if is_soft_bundle_request {
-                    return Err(error.into());
-                }
                 results[idx] = Some(SubmitTxResult::Rejected { error });
                 continue;
             }
@@ -738,15 +738,6 @@ impl ValidatorService {
             {
                 let effects_digest = effects.digest();
                 if let Ok(executed_data) = self.complete_executed_data(effects, None).await {
-                    // Avoid breaking the soft bundle if one transaction has already been executed.
-                    if is_soft_bundle_request {
-                        return Err(SuiError::UserInputError {
-                            error: UserInputError::AlreadyExecutedInSoftBundleError {
-                                digest: *tx_digest,
-                            },
-                        }
-                        .into());
-                    }
                     let executed_result = SubmitTxResult::Executed {
                         effects_digest,
                         details: Some(executed_data),
@@ -785,15 +776,6 @@ impl ValidatorService {
                         let effects_digest = effects.digest();
                         if let Ok(executed_data) = self.complete_executed_data(effects, None).await
                         {
-                            // Avoid breaking the soft bundle if one transaction has already been executed.
-                            if is_soft_bundle_request {
-                                return Err(SuiError::UserInputError {
-                                    error: UserInputError::AlreadyExecutedInSoftBundleError {
-                                        digest: *tx_digest,
-                                    },
-                                }
-                                .into());
-                            }
                             let executed_result = SubmitTxResult::Executed {
                                 effects_digest,
                                 details: Some(executed_data),
@@ -803,11 +785,7 @@ impl ValidatorService {
                             continue;
                         }
                     }
-                    // Avoid breaking the soft bundle if one transaction is rejected.
-                    if is_soft_bundle_request {
-                        return Err(e.into());
-                    }
-                    // Otherwise, record the error for the transaction.
+                    // If the transaction has not been executed, record the error for the transaction.
                     results[idx] = Some(SubmitTxResult::Rejected { error: e });
                     continue;
                 }

crates/sui-core/src/unit_tests/submit_transaction_tests.rs

@@ -577,20 +577,27 @@ async fn test_submit_soft_bundle_transactions_with_already_executed() {
     };
 
     // Submit request with batched transactions, using grpc client directly.
-    let error = test_context
+    let raw_response = test_context
         .client
         .client()
         .unwrap()
         .submit_transaction(request)
         .await
-        .unwrap_err()
-        .into();
+        .unwrap()
+        .into_inner();
 
-    // Verify the error is AlreadyExecutedInSoftBundleError.
-    assert!(matches!(
-        error,
-        SuiError::UserInputError {
-            error: UserInputError::AlreadyExecutedInSoftBundleError { .. }
+    // First should be already executed, second should be submitted
+    match &raw_response.results[0].inner {
+        Some(sui_types::messages_grpc::RawValidatorSubmitStatus::Executed(_)) => {
+            // Expected: first transaction was already executed
         }
-    ));
+        _ => panic!("Expected Executed status for first transaction"),
+    }
+
+    match &raw_response.results[1].inner {
+        Some(sui_types::messages_grpc::RawValidatorSubmitStatus::Submitted(_)) => {
+            // Expected: second transaction was submitted to consensus
+        }
+        _ => panic!("Expected Submitted status for second transaction"),
+    }
 }