[graphql-alt] Load just-published packages within Object::with_address (#23928)

## Description 

Currently, package queries that stem from simulated transactions produce
null outputs because they do not currently pay attention to the new
objects produced by the transaction. Support for reading from these new
objects has been added to the Object load paths, but although
MovePackages are objects, they are typically fetched from the
kv_packages table, which also needs to consult the transaction's output
objects.

This PR fixes that problem by adding a logic to
`MovePackage::with_address` to load the latest object version for a
given address.

## Test plan 

How did you test the new or updated feature?

```
cargo nextest run -p sui-indexer-alt-e2e-tests
cargo nextest run -p sui-indexer-alt-framework
```


---

## 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: 
- [x] GraphQL: Removed `events` field from `SimulationResult`. Events
are now only accessible via `effects.events()` to eliminate redundancy.
- [ ] CLI: 
- [ ] Rust SDK:

Author: tpham-mysten

crates/sui-indexer-alt-e2e-tests/tests/graphql_simulate_transaction_tests.rs

@@ -86,7 +86,6 @@ enum ArgumentKind {
 #[serde(rename_all = "camelCase")]
 struct SimulationResult {
     effects: Option<TransactionEffects>,
-    events: Option<Events>,
     outputs: Option<Vec<CommandResult>>,
     error: Option<String>,
 }
@@ -118,16 +117,6 @@ struct GasInput {
     gas_budget: String,
 }
 
-// Events is now a Vec<EventNode> directly, not wrapped in nodes
-type Events = Vec<EventNode>;
-
-#[derive(Debug, Deserialize)]
-struct EventNode {
-    #[serde(rename = "eventBcs")]
-    event_bcs: String,
-    sender: Sender,
-}
-
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 struct ObjectChangeNode {
@@ -348,12 +337,25 @@ async fn test_simulate_transaction_with_events() {
             query($txData: JSON!) {
                 simulateTransaction(transaction: $txData) {
                     effects {
-                        digest
                         status
-                    }
-                    events {
-                        eventBcs
-                        sender { address }
+                        events {
+                            nodes {
+                                contents {
+                                    json
+                                }
+                                transactionModule {
+                                    package {
+                                        version
+                                        modules {
+                                            nodes {
+                                                name
+                                            }         
+                                        }
+                                    }
+                                    name
+                                }
+                            }
+                        }
                     }
                     error
                 }
@@ -370,19 +372,40 @@ async fn test_simulate_transaction_with_events() {
         .await
         .expect("GraphQL request failed");
 
-    let simulation_result: SimulationResult =
-        serde_json::from_value(result.pointer("/data/simulateTransaction").unwrap().clone())
-            .unwrap();
-
-    // Verify events were simulated
-    let events = simulation_result.events.unwrap();
-    assert!(!events.is_empty());
-
-    let sender_address = validator_cluster.get_address_0();
-    for event_node in &events {
-        assert!(!event_node.event_bcs.is_empty());
-        assert_eq!(event_node.sender.address, sender_address.to_string());
+    // Verify package version and digest are populated correctly from execution context
+    insta::assert_json_snapshot!(result.pointer("/data/simulateTransaction"), @r#"
+    {
+      "effects": {
+        "status": "SUCCESS",
+        "events": {
+          "nodes": [
+            {
+              "contents": {
+                "json": {
+                  "message": "Package published successfully!",
+                  "value": "42"
+                }
+              },
+              "transactionModule": {
+                "package": {
+                  "version": 1,
+                  "modules": {
+                    "nodes": [
+                      {
+                        "name": "emit_event"
+                      }
+                    ]
+                  }
+                },
+                "name": "emit_event"
+              }
+            }
+          ]
+        }
+      },
+      "error": null
     }
+    "#);
 
     graphql_cluster.stopped().await;
 }

crates/sui-indexer-alt-framework/src/ingestion/rpc_client.rs

@@ -17,8 +17,8 @@ use crate::ingestion::ingestion_client::{
 #[async_trait]
 impl IngestionClientTrait for RpcClient {
     async fn fetch(&self, checkpoint: u64) -> FetchResult {
-        let request = GetCheckpointRequest::by_sequence_number(checkpoint).with_read_mask(
-            FieldMask::from_paths([
+        let request: GetCheckpointRequest = GetCheckpointRequest::by_sequence_number(checkpoint)
+            .with_read_mask(FieldMask::from_paths([
                 "summary.bcs",
                 "signature",
                 "contents.bcs",
@@ -27,8 +27,7 @@ impl IngestionClientTrait for RpcClient {
                 "transactions.effects.unchanged_loaded_runtime_objects",
                 "transactions.events.bcs",
                 "objects.objects.bcs",
-            ]),
-        );
+            ]));
 
         let response = self
             .clone()

crates/sui-indexer-alt-graphql/schema.graphql

@@ -3544,7 +3544,7 @@ type SharedInput {
 }
 
 """
-The result of simulating a transaction, including the predicted effects, events, and any errors.
+The result of simulating a transaction, including the predicted effects and any errors.
 """
 type SimulationResult {
 	"""
@@ -3560,12 +3560,6 @@ type SimulationResult {
 	"""
 	error: String
 	"""
-	The events that would be emitted if the transaction were executed.
-	
-	`None` if the simulation failed or no events would be emitted.
-	"""
-	events: [Event!]
-	"""
 	The intermediate outputs for each command of the transaction simulation, including contents of mutated references and return values.
 	"""
 	outputs: [CommandResult!]

crates/sui-indexer-alt-graphql/src/api/mutation.rs

@@ -77,10 +77,17 @@ impl Mutation {
             .await
         {
             Ok(response) => {
-                let scope = Scope::new(ctx)?;
-                let effects = TransactionEffects::from_execution_response(
+                let executed_transaction = response
+                    .transaction
+                    .as_ref()
+                    .ok_or_else(|| anyhow!("ExecuteTransactionResponse should have transaction"))?;
+
+                let scope = Scope::new(ctx)?
+                    .with_executed_transaction(executed_transaction)
+                    .map_err(crate::error::upcast)?;
+                let effects = TransactionEffects::from_executed_transaction(
                     scope,
-                    response,
+                    executed_transaction,
                     tx_data,
                     parsed_signatures,
                 )

crates/sui-indexer-alt-graphql/src/api/query.rs

@@ -600,7 +600,6 @@ impl Query {
             }
             Err(GrpcExecutionError(status)) => Ok(SimulationResult {
                 effects: None,
-                events: None,
                 outputs: None,
                 error: Some(status.to_string()),
             }),

crates/sui-indexer-alt-graphql/src/api/types/move_package.rs

@@ -522,7 +522,6 @@ impl MovePackage {
     /// user input. When the package's contents are fetched from the latest version of that object
     /// as of the current checkpoint.
     pub(crate) fn with_address(scope: Scope, address: NativeSuiAddress) -> Self {
-        // TODO: Look for the package in the scope (just-published packages).
         let super_ = Object::with_address(scope, address);
         Self {
             super_,

crates/sui-indexer-alt-graphql/src/api/types/object.rs

@@ -627,11 +627,23 @@ impl Object {
         }
     }
 
-    /// Construct an object that is represented by just its address. This does not check that the
-    /// object exists, so should not be used to "fetch" an address provided as user input. When the
-    /// object's contents are fetched from the latest version of that object as of the current
-    /// checkpoint.
+    /// Construct an object that is represented by just its address.
+    ///
+    /// This function first checks the execution context for freshly created/modified objects.
+    /// If found there, returns an Object with its contents already loaded. Otherwise, returns
+    /// an Object that will lazy-load its contents from the database when accessed.
+    ///
+    /// This does not verify that the object exists in the database (for the lazy-loading case),
+    /// so should not be used to "fetch" an address provided as user input. Contents from the
+    /// database are fetched from the latest version of that object available in the database,
+    /// which may not be as current as the checkpoint specified in scope.
     pub(crate) fn with_address(scope: Scope, address: NativeSuiAddress) -> Self {
+        // Check execution context first for freshly created/modified objects
+        if let Some(native_obj) = scope.execution_output_object_latest(address.into()) {
+            return Self::from_contents(scope.clone(), native_obj.clone());
+        }
+
+        // Fallback to lazy loading from database
         Self {
             super_: Address::with_address(scope, address),
             version_digest: None,

crates/sui-indexer-alt-graphql/src/api/types/simulation_result.rs

@@ -8,21 +8,16 @@ use sui_types::transaction::TransactionData;
 
 use crate::{error::RpcError, scope::Scope};
 
-use super::{command_result::CommandResult, event::Event, transaction_effects::TransactionEffects};
+use super::{command_result::CommandResult, transaction_effects::TransactionEffects};
 
-/// The result of simulating a transaction, including the predicted effects, events, and any errors.
+/// The result of simulating a transaction, including the predicted effects and any errors.
 #[derive(Clone, SimpleObject)]
 pub struct SimulationResult {
     /// The predicted effects of the transaction if it were executed.
     ///
     /// `None` if the simulation failed due to an error.
     pub effects: Option<TransactionEffects>,
 
-    /// The events that would be emitted if the transaction were executed.
-    ///
-    /// `None` if the simulation failed or no events would be emitted.
-    pub events: Option<Vec<Event>>,
-
     /// The intermediate outputs for each command of the transaction simulation, including contents of mutated references and return values.
     pub outputs: Option<Vec<CommandResult>>,
 
@@ -39,42 +34,20 @@ impl SimulationResult {
         response: proto::SimulateTransactionResponse,
         transaction_data: TransactionData,
     ) -> Result<Self, RpcError> {
-        let effects = Some(TransactionEffects::from_simulation_response(
-            scope.clone(),
-            response.clone(),
-            transaction_data.clone(),
-        )?);
-
-        // Parse events - break into clear steps
         let executed_transaction = response
             .transaction
             .as_ref()
-            .context("No transaction in simulation response")?;
+            .context("SimulateTransactionResponse should have transaction")?;
 
-        let events_bcs = executed_transaction
-            .events
-            .as_ref()
-            .and_then(|events| events.bcs.as_ref());
-
-        let transaction_events = events_bcs
-            .map(|bcs| bcs.deserialize())
-            .transpose()
-            .context("Failed to deserialize events BCS")?;
+        // Create scope with execution objects
+        let scope = scope.with_executed_transaction(executed_transaction)?;
 
-        let events = transaction_events.map(|events: sui_types::effects::TransactionEvents| {
-            events
-                .data
-                .into_iter()
-                .enumerate()
-                .map(|(sequence, native_event)| Event {
-                    scope: scope.clone(),
-                    native: native_event,
-                    transaction_digest: transaction_data.digest(),
-                    sequence_number: sequence as u64,
-                    timestamp_ms: 0, // No timestamp for simulation
-                })
-                .collect()
-        });
+        let effects = TransactionEffects::from_executed_transaction(
+            scope.clone(),
+            executed_transaction,
+            transaction_data.clone(),
+            vec![], // No signatures for simulated transactions
+        )?;
 
         // Extract command results from the response
         let outputs = Some(
@@ -86,8 +59,7 @@ impl SimulationResult {
         );
 
         Ok(Self {
-            effects,
-            events,
+            effects: Some(effects),
             outputs,
             error: None,
         })

crates/sui-indexer-alt-graphql/src/api/types/snapshots/sui_indexer_alt_graphql__api__types__available_range__field_piplines_tests__registry_collect_pipelines_snapshot.snap

@@ -1433,9 +1433,6 @@ SharedInput.mutable
 SimulationResult.effects
   => {}
 
-SimulationResult.events
-  => {}
-
 SimulationResult.outputs
   => {}
 

crates/sui-indexer-alt-graphql/src/api/types/transaction_effects.rs

@@ -17,7 +17,6 @@ use sui_types::{
     digests::TransactionDigest,
     effects::TransactionEffectsAPI,
     execution_status::ExecutionStatus as NativeExecutionStatus,
-    object::Object as NativeObject,
     signature::GenericSignature,
     transaction::{TransactionData, TransactionDataAPI},
 };
@@ -362,7 +361,7 @@ impl EffectsContents {
 
 impl TransactionEffects {
     /// Create a new TransactionEffects from an ExecutedTransaction.
-    fn from_executed_transaction(
+    pub(crate) fn from_executed_transaction(
         scope: Scope,
         executed_transaction: &ExecutedTransaction,
         transaction_data: TransactionData,
@@ -375,11 +374,9 @@ impl TransactionEffects {
         )
         .context("Failed to create TransactionContents from ExecutedTransaction")?;
 
-        let objects = extract_objects_from_executed_transaction(executed_transaction);
         let digest = contents
             .digest()
             .context("Failed to get digest from transaction contents")?;
-        let scope = scope.with_execution_output(objects);
 
         Ok(Self {
             digest,
@@ -390,35 +387,6 @@ impl TransactionEffects {
         })
     }
 
-    /// Create a new TransactionEffects from a gRPC ExecuteTransactionResponse.
-    pub(crate) fn from_execution_response(
-        scope: Scope,
-        response: sui_rpc::proto::sui::rpc::v2::ExecuteTransactionResponse,
-        transaction_data: TransactionData,
-        signatures: Vec<GenericSignature>,
-    ) -> Result<Self, RpcError> {
-        let executed_transaction = response
-            .transaction
-            .as_ref()
-            .context("ExecuteTransactionResponse should have transaction")?;
-
-        Self::from_executed_transaction(scope, executed_transaction, transaction_data, signatures)
-    }
-
-    /// Create a new TransactionEffects from a gRPC SimulateTransactionResponse.
-    pub(crate) fn from_simulation_response(
-        scope: Scope,
-        response: sui_rpc::proto::sui::rpc::v2::SimulateTransactionResponse,
-        transaction_data: TransactionData,
-    ) -> Result<Self, RpcError> {
-        let executed_transaction = response
-            .transaction
-            .as_ref()
-            .context("SimulateTransactionResponse should have transaction")?;
-
-        Self::from_executed_transaction(scope, executed_transaction, transaction_data, vec![])
-    }
-
     /// Load the effects from the store, and return it fully inflated (with contents already
     /// fetched). Returns `None` if the effects do not exist (either never existed or were pruned
     /// from the store).
@@ -499,16 +467,3 @@ impl From<Transaction> for TransactionEffects {
         }
     }
 }
-
-/// Extract input and output object contents from an ExecutedTransaction.
-fn extract_objects_from_executed_transaction(
-    executed_transaction: &ExecutedTransaction,
-) -> Vec<NativeObject> {
-    executed_transaction
-        .objects()
-        .objects()
-        .iter()
-        .filter_map(|obj| obj.bcs.as_ref())
-        .map(|bcs| bcs.deserialize().expect("Object BCS should be valid"))
-        .collect()
-}