Rename contains_shared_object to is_consensus_tx (#22492)

## Description 

We will no longer be able to simply use shared objects to determine
whether a transaction is a consensus transaction, due to withdraws.
Removing this interface to make it less error prone.

## Test plan 

How did you test the new or updated feature?

---

## Release notes

Check each box that your changes affect. If none of the boxes relate to
your changes, release notes aren't required.

For each box you select, include information after the relevant heading
that describes the impact of your changes that a user might notice and
any actions they must take to implement updates.

- [ ] Protocol: 
- [ ] Nodes (Validators and Full nodes): 
- [ ] gRPC:
- [ ] JSON-RPC: 
- [ ] GraphQL: 
- [ ] CLI: 
- [ ] Rust SDK:

Author: lxfind

crates/sui-core/src/authority.rs

@@ -1281,7 +1281,7 @@ impl AuthorityState {
         transaction: &VerifiedExecutableTransaction,
         epoch_store: &Arc<AuthorityPerEpochStore>,
     ) -> SuiResult<TransactionEffects> {
-        let _metrics_guard = if transaction.contains_shared_object() {
+        let _metrics_guard = if transaction.is_consensus_tx() {
             self.metrics
                 .execute_certificate_latency_shared_object
                 .start_timer()
@@ -1294,8 +1294,7 @@ impl AuthorityState {
 
         self.metrics.total_cert_attempts.inc();
 
-        // TODO(fastpath): use a separate function to check if a transaction should be executed in fastpath.
-        if !transaction.contains_shared_object() {
+        if !transaction.is_consensus_tx() {
             // Shared object transactions need to be sequenced by the consensus before enqueueing
             // for execution, done in AuthorityPerEpochStore::handle_consensus_transaction().
             // For owned object transactions, they can be enqueued for execution immediately.
@@ -1367,7 +1366,7 @@ impl AuthorityState {
 
         let tx_cache_reader = self.get_transaction_cache_reader();
         if epoch_store.protocol_config().mysticeti_fastpath()
-            && !certificate.contains_shared_object()
+            && !certificate.is_consensus_tx()
             && execution_env.scheduling_source == SchedulingSource::NonFastPath
         {
             // If this transaction is not scheduled from fastpath, it must be either

crates/sui-core/src/authority/authority_per_epoch_store.rs

@@ -4230,7 +4230,7 @@ impl AuthorityPerEpochStore {
         }
 
         // If needed we can support owned object system transactions as well...
-        assert!(system_transaction.contains_shared_object());
+        assert!(system_transaction.is_consensus_tx());
         ConsensusCertificateResult::SuiTransaction(system_transaction.clone())
     }
 
@@ -4345,10 +4345,8 @@ impl AuthorityPerEpochStore {
         }
 
         // This certificate will be scheduled. Update object execution cost.
-        if transaction.contains_shared_object() {
-            shared_object_congestion_tracker
-                .bump_object_execution_cost(execution_time_estimator, &transaction);
-        }
+        shared_object_congestion_tracker
+            .bump_object_execution_cost(execution_time_estimator, &transaction);
 
         Ok(ConsensusCertificateResult::SuiTransaction(transaction))
     }

crates/sui-core/src/authority/shared_object_congestion_tracker.rs

@@ -151,10 +151,10 @@ impl SharedObjectCongestionTracker {
         trace!(
             "created SharedObjectCongestionTracker with
              {} initial object debts,
-             mode: {mode:?}, 
-             max_accumulated_txn_cost_per_object_in_commit: {max_accumulated_txn_cost_per_object_in_commit:?}, 
-             gas_budget_based_txn_cost_cap_factor: {gas_budget_based_txn_cost_cap_factor:?}, 
-             gas_budget_based_txn_cost_absolute_cap: {gas_budget_based_txn_cost_absolute_cap:?}, 
+             mode: {mode:?},
+             max_accumulated_txn_cost_per_object_in_commit: {max_accumulated_txn_cost_per_object_in_commit:?},
+             gas_budget_based_txn_cost_cap_factor: {gas_budget_based_txn_cost_cap_factor:?},
+             gas_budget_based_txn_cost_absolute_cap: {gas_budget_based_txn_cost_absolute_cap:?},
              max_txn_cost_overage_per_object_in_commit: {max_txn_cost_overage_per_object_in_commit:?}",
             object_execution_cost.len(),
         );
@@ -260,7 +260,7 @@ impl SharedObjectCongestionTracker {
 
         let shared_input_objects: Vec<_> = cert.shared_input_objects().collect();
         if shared_input_objects.is_empty() {
-            // This is an owned object only transaction. No need to defer.
+            // No shared object used by this transaction. No need to defer.
             return None;
         }
         let start_cost = self.compute_tx_start_at_cost(&shared_input_objects);
@@ -281,7 +281,7 @@ impl SharedObjectCongestionTracker {
         // Note that the congested objects here may be caused by transaction dependency of other congested objects.
         // Consider in a consensus commit, there are many transactions touching object A, and later in processing the
         // consensus commit, there is a transaction touching both object A and B. Although there are fewer transactions
-        // touching object B, becase it's starting execution is delayed due to dependency to other transactions on
+        // touching object B, because it's starting execution is delayed due to dependency to other transactions on
         // object A, it may be shown up as congested objects.
         let mut congested_objects = vec![];
         for obj in shared_input_objects {
@@ -319,11 +319,15 @@ impl SharedObjectCongestionTracker {
         execution_time_estimator: Option<&ExecutionTimeEstimator>,
         cert: &VerifiedExecutableTransaction,
     ) {
+        let shared_input_objects: Vec<_> = cert.shared_input_objects().collect();
+        if shared_input_objects.is_empty() {
+            return;
+        }
+
         let Some(tx_cost) = self.get_tx_cost(execution_time_estimator, cert) else {
             return;
         };
 
-        let shared_input_objects: Vec<_> = cert.shared_input_objects().collect();
         let start_cost = self.compute_tx_start_at_cost(&shared_input_objects);
         let end_cost = start_cost.saturating_add(tx_cost);
 

crates/sui-core/src/authority/shared_object_version_manager.rs

@@ -117,16 +117,6 @@ impl<T> Schedulable<T> {
         }
     }
 
-    pub fn contains_shared_object(&self) -> bool
-    where
-        T: AsTx,
-    {
-        match self {
-            Schedulable::Transaction(tx) => tx.as_tx().contains_shared_object(),
-            Schedulable::RandomnessStateUpdate(_, _) => true,
-        }
-    }
-
     pub fn non_shared_input_object_keys(&self) -> Vec<ObjectKey>
     where
         T: AsTx,
@@ -187,9 +177,6 @@ impl SharedObjVerManager {
         )?;
         let mut assigned_versions = Vec::new();
         for assignable in assignables {
-            if !assignable.contains_shared_object() {
-                continue;
-            }
             let cert_assigned_versions = Self::assign_versions_for_certificate(
                 epoch_store,
                 assignable,
@@ -260,6 +247,12 @@ impl SharedObjVerManager {
         shared_input_next_versions: &mut HashMap<ConsensusObjectSequenceKey, SequenceNumber>,
         cancelled_txns: &BTreeMap<TransactionDigest, CancelConsensusCertificateReason>,
     ) -> AssignedVersions {
+        let shared_input_objects: Vec<_> = assignable.shared_input_objects(epoch_store).collect();
+        if shared_input_objects.is_empty() {
+            // No shared object used by this transaction. No need to assign versions.
+            return vec![];
+        }
+
         let tx_key = assignable.key();
 
         // Check if the transaction is cancelled due to congestion.
@@ -276,9 +269,6 @@ impl SharedObjVerManager {
             };
         let txn_cancelled = cancellation_info.is_some();
 
-        // Make an iterator to update the locks of the transaction's shared objects.
-        let shared_input_objects: Vec<_> = assignable.shared_input_objects(epoch_store).collect();
-
         let mut input_object_keys = assignable.non_shared_input_object_keys();
         let mut assigned_versions = Vec::with_capacity(shared_input_objects.len());
         let mut is_mutable_input = Vec::with_capacity(shared_input_objects.len());

crates/sui-core/src/authority_server.rs

@@ -638,13 +638,11 @@ impl ValidatorService {
             SuiError::FullNodeCantHandleCertificate.into()
         );
 
-        let shared_object_tx = certificates
-            .iter()
-            .any(|cert| cert.contains_shared_object());
+        let is_consensus_tx = certificates.iter().any(|cert| cert.is_consensus_tx());
 
         let metrics = if certificates.len() == 1 {
             if wait_for_effects {
-                if shared_object_tx {
+                if is_consensus_tx {
                     &self.metrics.handle_certificate_consensus_latency
                 } else {
                     &self.metrics.handle_certificate_non_consensus_latency
@@ -853,11 +851,11 @@ impl ValidatorService {
         if !wait_for_effects {
             // It is useful to enqueue owned object transaction for execution locally,
             // even when we are not returning effects to user
-            let certificates_without_shared_objects = consensus_transactions
+            let fast_path_certificates = consensus_transactions
                 .iter()
                 .filter_map(|tx| {
                     if let ConsensusTransactionKind::CertifiedTransaction(certificate) = &tx.kind {
-                        (!certificate.contains_shared_object())
+                        (!certificate.is_consensus_tx())
                             // Certificates already verified by callers of this function.
                             .then_some((
                                 VerifiedExecutableTransaction::new_from_certificate(
@@ -872,10 +870,10 @@ impl ValidatorService {
                 })
                 .map(|(tx, env)| (Schedulable::Transaction(tx), env))
                 .collect::<Vec<_>>();
-            if !certificates_without_shared_objects.is_empty() {
+            if !fast_path_certificates.is_empty() {
                 self.state
                     .execution_scheduler()
-                    .enqueue(certificates_without_shared_objects, epoch_store);
+                    .enqueue(fast_path_certificates, epoch_store);
             }
             return Ok((None, Weight::zero()));
         }
@@ -1300,7 +1298,7 @@ impl ValidatorService {
         for certificate in certificates {
             let tx_digest = *certificate.digest();
             fp_ensure!(
-                certificate.contains_shared_object(),
+                certificate.is_consensus_tx(),
                 SuiError::UserInputError {
                     error: UserInputError::NoSharedObjectError { digest: tx_digest }
                 }

crates/sui-core/src/consensus_handler.rs

@@ -1005,7 +1005,7 @@ impl<C> ConsensusHandler<C> {
 pub(crate) fn classify(transaction: &ConsensusTransaction) -> &'static str {
     match &transaction.kind {
         ConsensusTransactionKind::CertifiedTransaction(certificate) => {
-            if certificate.contains_shared_object() {
+            if certificate.is_consensus_tx() {
                 "shared_certificate"
             } else {
                 "owned_certificate"
@@ -1020,7 +1020,7 @@ pub(crate) fn classify(transaction: &ConsensusTransaction) -> &'static str {
         ConsensusTransactionKind::RandomnessDkgMessage(_, _) => "randomness_dkg_message",
         ConsensusTransactionKind::RandomnessDkgConfirmation(_, _) => "randomness_dkg_confirmation",
         ConsensusTransactionKind::UserTransaction(tx) => {
-            if tx.contains_shared_object() {
+            if tx.is_consensus_tx() {
                 "shared_user_transaction"
             } else {
                 "owned_user_transaction"
@@ -1202,17 +1202,17 @@ impl SequencedConsensusTransaction {
         }
     }
 
-    pub fn as_shared_object_txn(&self) -> Option<&SenderSignedData> {
+    pub fn as_consensus_txn(&self) -> Option<&SenderSignedData> {
         match &self.transaction {
             SequencedConsensusTransactionKind::External(ConsensusTransaction {
                 kind: ConsensusTransactionKind::CertifiedTransaction(certificate),
                 ..
-            }) if certificate.contains_shared_object() => Some(certificate.data()),
+            }) if certificate.is_consensus_tx() => Some(certificate.data()),
             SequencedConsensusTransactionKind::External(ConsensusTransaction {
                 kind: ConsensusTransactionKind::UserTransaction(txn),
                 ..
-            }) if txn.contains_shared_object() => Some(txn.data()),
-            SequencedConsensusTransactionKind::System(txn) if txn.contains_shared_object() => {
+            }) if txn.is_consensus_tx() => Some(txn.data()),
+            SequencedConsensusTransactionKind::System(txn) if txn.is_consensus_tx() => {
                 Some(txn.data())
             }
             _ => None,
@@ -1317,8 +1317,7 @@ impl ConsensusBlockHandler {
                     .with_label_values(&["certified"])
                     .inc();
                 if let ConsensusTransactionKind::UserTransaction(tx) = parsed.transaction.kind {
-                    // TODO(fastpath): use a separate function to check if a transaction should be executed in fastpath.
-                    if tx.contains_shared_object() {
+                    if tx.is_consensus_tx() {
                         continue;
                     }
                     let tx = VerifiedTransaction::new_unchecked(*tx);

crates/sui-core/src/mock_consensus.rs

@@ -88,7 +88,7 @@ impl MockConsensusClient {
             };
             match &tx.kind {
                 ConsensusTransactionKind::CertifiedTransaction(tx) => {
-                    if tx.contains_shared_object() {
+                    if tx.is_consensus_tx() {
                         validator.execution_scheduler().enqueue(
                             vec![(
                                 VerifiedExecutableTransaction::new_from_certificate(
@@ -102,7 +102,7 @@ impl MockConsensusClient {
                     }
                 }
                 ConsensusTransactionKind::UserTransaction(tx) => {
-                    if tx.contains_shared_object() {
+                    if tx.is_consensus_tx() {
                         validator.execution_scheduler().enqueue(
                             vec![(
                                 VerifiedExecutableTransaction::new_from_consensus(

crates/sui-core/src/quorum_driver/mod.rs

@@ -596,7 +596,7 @@ where
         } = task;
         let transaction = &request.transaction;
         let tx_digest = *transaction.digest();
-        let is_single_writer_tx = !transaction.contains_shared_object();
+        let is_single_writer_tx = !transaction.is_consensus_tx();
 
         let timer = Instant::now();
         let (tx_cert, newly_formed) = match tx_cert {

crates/sui-core/src/transaction_driver/mod.rs

@@ -76,7 +76,7 @@ where
         options: SubmitTransactionOptions,
     ) -> Result<QuorumSubmitTransactionResponse, TransactionDriverError> {
         let tx_digest = request.transaction.digest();
-        let is_single_writer_tx = !request.transaction.contains_shared_object();
+        let is_single_writer_tx = !request.transaction.is_consensus_tx();
         let timer = Instant::now();
         loop {
             match self.submit_transaction_once(&request, &options).await {

crates/sui-core/src/transaction_orchestrator.rs

@@ -236,7 +236,7 @@ where
         let tx_digest = *transaction.digest();
         debug!(?tx_digest, "TO Received transaction execution request.");
 
-        let (_e2e_latency_timer, _txn_finality_timer) = if transaction.contains_shared_object() {
+        let (_e2e_latency_timer, _txn_finality_timer) = if transaction.is_consensus_tx() {
             (
                 self.metrics.request_latency_shared_obj.start_timer(),
                 self.metrics
@@ -354,7 +354,7 @@ where
                 in_flight.dec();
             });
 
-        let _guard = if transaction.contains_shared_object() {
+        let _guard = if transaction.is_consensus_tx() {
             metrics.local_execution_latency_shared_obj.start_timer()
         } else {
             metrics.local_execution_latency_single_writer.start_timer()
@@ -446,7 +446,7 @@ where
         &'_ self,
         transaction: &VerifiedTransaction,
     ) -> (impl Drop, &'_ GenericCounter<AtomicU64>) {
-        let (in_flight, good_response) = if transaction.contains_shared_object() {
+        let (in_flight, good_response) = if transaction.is_consensus_tx() {
             self.metrics.total_req_received_shared_object.inc();
             (
                 self.metrics.req_in_flight_shared_object.clone(),