[3/6] Generalize accumulator version into a system object versions map (#27104)

## Description

Stack of 6 (builds on [2/6]). Generalizes
`AssignedVersions.accumulator_version` (a single
`Option<SequenceNumber>`) into a `system_object_versions:
BTreeMap<ObjectID, SequenceNumber>` map, so consensus version assignment
can pin arbitrary system objects — not just the accumulator root — to
the version a transaction is sequenced against, and wires the authority
to pass that map straight into execution (replacing the
accumulator-root-only map built inline in [1/6]). An
`accumulator_version()` accessor keeps existing callers working. Pure
refactor: the map still holds at most the accumulator root version
today, so behavior is unchanged.

## Test plan

Covered by the existing `shared_object_version_manager` unit tests,
updated to construct `AssignedVersions` through the new API, and by the
address-funds e2e tests, which assign the accumulator version for
object-funds withdrawals and exercise the `accumulator_version()`
accessor end to end.

## Release notes

Check each box that your change affects. If none of the boxes relate to
your changes, release notes are not required.

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

Author: lxfind

crates/sui-core/src/accumulators/object_funds_checker/integration_tests.rs

@@ -175,8 +175,10 @@ impl TestEnv {
 
     fn execution_env(&self) -> ExecutionEnv {
         let accumulator_version = self.oref(&SUI_ACCUMULATOR_ROOT_OBJECT_ID).1;
-        ExecutionEnv::new()
-            .with_assigned_versions(AssignedVersions::new(vec![], Some(accumulator_version)))
+        ExecutionEnv::new().with_assigned_versions(AssignedVersions::new_for_testing(
+            vec![],
+            Some(accumulator_version),
+        ))
     }
 
     /// Executes at the current accumulator version, expecting success.
@@ -236,8 +238,10 @@ async fn test_object_withdraw_basic_flow() {
         .authority
         .try_execute_immediately(
             &cert,
-            ExecutionEnv::new()
-                .with_assigned_versions(AssignedVersions::new(vec![], Some(accumulator_version))),
+            ExecutionEnv::new().with_assigned_versions(AssignedVersions::new_for_testing(
+                vec![],
+                Some(accumulator_version),
+            )),
             &env.epoch_store,
         )
         .unwrap()
@@ -270,7 +274,7 @@ async fn test_object_withdraw_multiple_withdraws() {
             // Fastpath execution
             .try_execute_immediately(
                 &cert,
-                ExecutionEnv::new().with_assigned_versions(AssignedVersions::new(
+                ExecutionEnv::new().with_assigned_versions(AssignedVersions::new_for_testing(
                     vec![],
                     Some(accumulator_version),
                 )),
@@ -309,7 +313,7 @@ async fn test_object_withdraw_multiple_withdraws() {
             // Fastpath execution
             .try_execute_immediately(
                 &cert,
-                ExecutionEnv::new().with_assigned_versions(AssignedVersions::new(
+                ExecutionEnv::new().with_assigned_versions(AssignedVersions::new_for_testing(
                     vec![],
                     Some(accumulator_version),
                 )),

crates/sui-core/src/accumulators/object_funds_checker/mod.rs

@@ -124,7 +124,8 @@ impl ObjectFundsChecker {
         // for the epoch, and every production path that produces such a tx also
         // assigns an accumulator version. The `None` paths (accumulator-disabled
         // epoch, end-of-epoch tx) never produce withdraws and so never reach here.
-        let Some(accumulator_version) = execution_env.assigned_versions.accumulator_version else {
+        let Some(accumulator_version) = execution_env.assigned_versions.accumulator_version()
+        else {
             debug_fatal!("accumulator_version must be set for a tx with object withdraws");
             return false;
         };

crates/sui-core/src/accumulators/object_funds_checker/unit_tests.rs

@@ -399,7 +399,7 @@ async fn test_should_commit_early_exits() {
         &tx,
         &TestEffectsBuilder::new(tx.data()).build(),
         &withdraws,
-        &ExecutionEnv::new().with_assigned_versions(AssignedVersions::new(
+        &ExecutionEnv::new().with_assigned_versions(AssignedVersions::new_for_testing(
             vec![],
             Some(SequenceNumber::from_u64(0))
         )),
@@ -419,7 +419,7 @@ async fn test_should_commit_early_exits() {
                 )))
                 .build(),
             &withdraws,
-            &ExecutionEnv::new().with_assigned_versions(AssignedVersions::new(
+            &ExecutionEnv::new().with_assigned_versions(AssignedVersions::new_for_testing(
                 vec![],
                 Some(SequenceNumber::from_u64(0))
             )),
@@ -482,7 +482,7 @@ async fn test_should_commit_ignores_zero_net_withdraws() {
         &tx,
         &effects,
         &running_max_withdraws,
-        &ExecutionEnv::new().with_assigned_versions(AssignedVersions::new(
+        &ExecutionEnv::new().with_assigned_versions(AssignedVersions::new_for_testing(
             vec![],
             Some(SequenceNumber::from_u64(0))
         )),

crates/sui-core/src/authority.rs

@@ -1541,7 +1541,7 @@ impl AuthorityState {
             return ExecutionOutput::EpochEnded;
         }
 
-        let accumulator_version = execution_env.assigned_versions.accumulator_version;
+        let accumulator_version = execution_env.assigned_versions.accumulator_version();
 
         let (transaction_outputs, timings, execution_error_opt) = match self.process_certificate(
             &tx_guard,
@@ -2060,15 +2060,14 @@ impl AuthorityState {
             self.config.certificate_deny_config.certificate_deny_set(),
             &execution_env.funds_withdraw_status,
         );
-        let accumulator_version = execution_env.assigned_versions.accumulator_version;
-        // The accumulator root is the only system object a transaction is sequenced against today.
-        // Pin its version so execution can gate reads on it and record a retry if this node has not
-        // caught up; see `TemporaryStore::check_system_object_available`. A later PR generalizes this
-        // to an arbitrary set of system objects.
-        let system_object_versions: BTreeMap<ObjectID, SequenceNumber> = accumulator_version
-            .map(|v| (SUI_ACCUMULATOR_ROOT_OBJECT_ID, v))
-            .into_iter()
-            .collect();
+        // Versions of system objects this transaction may read during execution, each at the version
+        // it was sequenced against. Execution gates reads on these (and records a retry if an object
+        // has not caught up); see `TemporaryStore::check_system_object_available`.
+        let system_object_versions = execution_env
+            .assigned_versions
+            .system_object_versions
+            .clone();
+        let accumulator_version = execution_env.assigned_versions.accumulator_version();
         let execution_params = match early_execution_error {
             None => ExecutionOrEarlyError::ok(accumulator_version),
             Some(errors) => ExecutionOrEarlyError::failed(errors, accumulator_version),
@@ -2082,7 +2081,7 @@ impl AuthorityState {
                 &*self.coin_reservation_resolver,
                 sender,
                 &mut kind,
-                execution_env.assigned_versions.accumulator_version,
+                execution_env.assigned_versions.accumulator_version(),
             )
             .expect("rewriting must succeed for a certified transaction")
         } else {

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

@@ -99,7 +99,7 @@ pub async fn submit_to_consensus(
         .into_map()
         .get(&executable.key())
         .cloned()
-        .unwrap_or_else(|| AssignedVersions::new(vec![], None));
+        .unwrap_or_default();
 
     Ok((executable, versions))
 }
@@ -182,9 +182,9 @@ pub async fn submit_and_execute_with_error(
             .into_map()
             .get(&executable.key())
             .cloned()
-            .unwrap_or_else(|| AssignedVersions::new(vec![], None))
+            .unwrap_or_default()
     } else {
-        AssignedVersions::new(vec![], None)
+        AssignedVersions::default()
     };
 
     // State accumulator for validation
@@ -460,7 +460,7 @@ pub async fn assign_versions_and_schedule(
         .into_map()
         .get(&executable.key())
         .cloned()
-        .unwrap_or_else(|| AssignedVersions::new(vec![], None));
+        .unwrap_or_default();
 
     let env = ExecutionEnv::new().with_assigned_versions(versions.clone());
     authority.execution_scheduler().enqueue_transactions(
@@ -489,5 +489,5 @@ pub async fn assign_shared_object_versions(
         .into_map()
         .get(&executable.key())
         .cloned()
-        .unwrap_or_else(|| AssignedVersions::new(vec![], None))
+        .unwrap_or_default()
 }