feat: use SenderSignedData input objects

Author: valeriyr

crates/iota-analytics-indexer/src/handlers/mod.rs

@@ -97,10 +97,11 @@ impl InputObjectTracker {
             .collect();
         let tx_data = txn.transaction_data();
         let coins: BTreeSet<ObjectID> = tx_data.gas().iter().map(|obj_ref| obj_ref.0).collect();
-        let input: BTreeSet<ObjectID> = tx_data
+        // All input objects (transaction + authenticators) are collected here, just
+        // like the shared objects previously.
+        let input: BTreeSet<ObjectID> = txn
             .input_objects()
             .expect("Input objects must be valid")
-            .iter()
             .map(|io_kind| io_kind.object_id())
             .collect();
         Self {

crates/iota-analytics-indexer/src/handlers/transaction_handler.rs

@@ -154,10 +154,11 @@ impl TransactionHandler {
             is_sponsored_tx,
             transaction_count: txn_data.kind().num_commands() as u64,
             execution_success: effects.status().is_ok(),
-            input: txn_data
+            // Calculate all objects(transaction + authenticators) amount.
+            input: transaction
                 .input_objects()
                 .expect("Input objects must be valid")
-                .len() as u64,
+                .count() as u64,
             shared_input: transaction.shared_input_objects().count() as u64,
             gas_coins: txn_data.gas().len() as u64,
             created: effects.created().len() as u64,

crates/iota-analytics-indexer/src/handlers/transaction_objects_handler.rs

@@ -10,7 +10,6 @@ use iota_types::{
     base_types::ObjectID,
     effects::TransactionEffects,
     full_checkpoint_content::{CheckpointData, CheckpointTransaction},
-    transaction::TransactionDataAPI,
 };
 use tokio::sync::Mutex;
 
@@ -97,13 +96,14 @@ impl TransactionObjectsHandler {
         let object_status_tracker = ObjectStatusTracker::new(effects);
 
         let transaction_digest = transaction.digest().base58_encode();
-        let txn_data = transaction.transaction_data();
 
         // input
-        txn_data
+        //
+        // Process all objects associated with the transaction, including authenticator
+        // inputs.
+        transaction
             .input_objects()
             .expect("Input objects must be valid")
-            .iter()
             .map(|object| (object.object_id(), object.version().map(|v| v.value())))
             .for_each(|(object_id, version)| {
                 self.process_transaction_object(

crates/iota-core/src/authority.rs

@@ -889,14 +889,17 @@ impl AuthorityState {
 
         let tx_data = transaction.data().transaction_data();
 
+        let tx_and_auth_input_objects = transaction.input_objects()?.collect::<Vec<_>>();
+        let tx_receiving_objects = tx_data.receiving_objects();
+
         // Note: the deny checks may do redundant package loads but:
         // - they only load packages when there is an active package deny map
         // - the loads are cached anyway
         iota_transaction_checks::deny::check_transaction_for_signing(
             tx_data,
             transaction.tx_signatures(),
-            &tx_data.input_objects()?,
-            &tx_data.receiving_objects(),
+            &tx_and_auth_input_objects,
+            &tx_receiving_objects,
             &self.config.transaction_deny_config,
             self.get_backing_package_store().as_ref(),
         )?;
@@ -905,8 +908,13 @@ impl AuthorityState {
         // Authenticator input objects and the account object are loaded in the same
         // call if there is a sender `MoveAuthenticator` signature present in the
         // transaction.
-        let (tx_input_objects, tx_receiving_objects, auth_input_objects, account_object) =
-            self.read_objects_for_signing(&transaction, epoch)?;
+        let (tx_input_objects, tx_receiving_objects, auth_input_objects, account_object) = self
+            .read_objects_for_signing(
+                &transaction,
+                &tx_and_auth_input_objects,
+                &tx_receiving_objects,
+                epoch,
+            )?;
 
         // Get the sender `MoveAuthenticator`, if any.
         // Only one `MoveAuthenticator` signature is possible, since it is not
@@ -1182,12 +1190,15 @@ impl AuthorityState {
         let observed_effects_digest = observed_effects.digest();
         if &observed_effects_digest != expected_effects_digest {
             panic!(
-                "Locally executed effects do not match canonical effects! expected_effects_digest={:?} observed_effects_digest={:?} expected_effects={:?} observed_effects={:?} input_objects={:?}",
+                "Locally executed effects do not match canonical effects! expected_effects_digest={:?} observed_effects_digest={:?} expected_effects={:?} observed_effects={:?} transaction_input_objects={:?} authenticator_input_objects={:?}",
                 expected_effects_digest,
                 observed_effects_digest,
                 effects.data(),
                 observed_effects,
-                transaction.data().transaction_data().input_objects()
+                transaction.data().transaction_data().input_objects(),
+                transaction
+                    .sender_move_authenticator()
+                    .map(|a| a.input_objects())
             );
         }
         Ok(())
@@ -1314,7 +1325,7 @@ impl AuthorityState {
             .execution_load_input_objects_latency
             .start_timer();
 
-        let input_objects = certificate.collect_all_inputs()?;
+        let input_objects = certificate.input_objects()?.collect::<Vec<_>>();
 
         let input_objects = self.input_loader.read_objects_for_execution(
             epoch_store,
@@ -5454,6 +5465,8 @@ impl AuthorityState {
     fn read_objects_for_signing(
         &self,
         transaction: &VerifiedTransaction,
+        input_object_kinds: &[InputObjectKind],
+        receiving_objects: &[ObjectRef],
         epoch: u64,
     ) -> IotaResult<(
         InputObjects,
@@ -5463,8 +5476,8 @@ impl AuthorityState {
     )> {
         let (input_objects, tx_receiving_objects) = self.input_loader.read_objects_for_signing(
             Some(transaction.digest()),
-            &transaction.collect_all_inputs()?,
-            &transaction.data().transaction_data().receiving_objects(),
+            &input_object_kinds,
+            &receiving_objects,
             epoch,
         )?;
 

crates/iota-core/src/transaction_manager.rs

@@ -449,12 +449,12 @@ impl TransactionManager {
             certs
                 .into_iter()
                 .filter_map(|(cert, fx_digest)| {
+                    // Check availability of all transaction associated input objects(transaction +
+                    // authenticators).
                     let input_object_kinds = cert
-                        .data()
-                        .intent_message()
-                        .value
                         .input_objects()
-                        .expect("input_objects() cannot fail");
+                        .expect("input_objects() cannot fail")
+                        .collect::<Vec<_>>();
                     let mut input_object_keys = match epoch_store
                         .get_input_object_keys(&cert.key(), &input_object_kinds)
                     {

crates/iota-types/src/move_authenticator.rs

@@ -123,6 +123,7 @@ impl MoveAuthenticator {
     }
 
     pub fn input_objects(&self) -> Vec<InputObjectKind> {
+        // TODO: validate uniqueness as it is done for transaction input objects.
         self.call_args
             .iter()
             .flat_map(|arg| arg.input_objects())

crates/iota-types/src/storage/mod.rs

@@ -529,10 +529,7 @@ pub fn transaction_non_shared_input_object_keys(
 ) -> IotaResult<Vec<ObjectKey>> {
     use crate::transaction::InputObjectKind as I;
     Ok(tx
-        .intent_message()
-        .value
         .input_objects()?
-        .into_iter()
         .filter_map(|object| match object {
             I::MovePackage(_) | I::SharedMoveObject { .. } => None,
             I::ImmOrOwnedMoveObject(obj) => Some(obj.into()),

crates/iota-types/src/transaction.rs

@@ -2528,25 +2528,6 @@ impl SenderSignedData {
             })
     }
 
-    /// Returns all input objects including those from the sender
-    /// `MoveAuthenticator` if any.
-    pub fn collect_all_inputs(&self) -> IotaResult<Vec<InputObjectKind>> {
-        if let Some(move_authenticator) = self.sender_move_authenticator() {
-            let mut input_objects_set = self
-                .transaction_data()
-                .input_objects()?
-                .into_iter()
-                .collect::<HashSet<_>>();
-
-            input_objects_set.extend(move_authenticator.input_objects());
-            input_objects_set.extend(move_authenticator.object_to_authenticate().input_objects());
-
-            Ok(input_objects_set.into_iter().collect::<Vec<_>>())
-        } else {
-            Ok(self.transaction_data().input_objects()?)
-        }
-    }
-
     /// Splits the provided input objects into three groups:
     /// 1. Input objects required by the transaction itself.
     /// 2. Input objects required by the sender `MoveAuthenticator`.
@@ -2646,6 +2627,33 @@ impl SenderSignedData {
             .unique()
     }
 
+    /// Returns an iterator over all input objects related to this
+    /// transaction, including those from the `MoveAuthenticator` if any.
+    pub fn input_objects(&self) -> IotaResult<impl Iterator<Item = InputObjectKind> + '_> {
+        // Add the Move authenticator input objects if any.
+        let authenticator_input_objects =
+            if let Some(move_authenticator) = self.sender_move_authenticator() {
+                move_authenticator
+                    .input_objects()
+                    .into_iter()
+                    // Add `object_to_authenticate` input object.
+                    .chain(move_authenticator.object_to_authenticate().input_objects())
+                    .collect::<Vec<_>>()
+                    .into_iter()
+            } else {
+                Vec::new().into_iter()
+            };
+
+        Ok(self
+            .inner()
+            .intent_message
+            .value
+            .input_objects()?
+            .into_iter()
+            .chain(authenticator_input_objects)
+            .unique())
+    }
+
     /// Checks if `SenderSignedData` contains the `Random` object as an
     /// input.
     /// This function checks shared objects from the `MoveAuthenticator` if any.