Revert "[3/n][object runtime type tags] Add type tags to object runtime update adapter to handle them (#22092)" and "[sui-adapter] Add basic package cache (#22099)"

This reverts commit b4ea7a4.

Author: Timothy Zakian

crates/sui-adapter-transactional-tests/tests/init/create_object.move

@@ -1375,7 +1375,6 @@
                 "soft_bundle": false,
                 "throughput_aware_consensus_submission": false,
                 "txn_base_cost_as_multiplier": false,
-                "type_tags_in_object_runtime": false,
                 "uncompressed_g1_group_elements": false,
                 "upgraded_multisig_supported": false,
                 "validate_identifier_inputs": false,

crates/sui-adapter-transactional-tests/tests/init/create_object.snap

@@ -694,10 +694,6 @@ struct FeatureFlags {
     // Enable native function for party transfer
     #[serde(skip_serializing_if = "is_false")]
     enable_party_transfer: bool,
-
-    // Signifies the cut-over of using type tags instead of `Type`s in the object runtime.
-    #[serde(skip_serializing_if = "is_false")]
-    type_tags_in_object_runtime: bool,
 }
 
 fn is_false(b: &bool) -> bool {
@@ -1982,10 +1978,6 @@ impl ProtocolConfig {
     pub fn enable_party_transfer(&self) -> bool {
         self.feature_flags.enable_party_transfer
     }
-
-    pub fn type_tags_in_object_runtime(&self) -> bool {
-        self.feature_flags.type_tags_in_object_runtime
-    }
 }
 
 #[cfg(not(msim))]
@@ -3547,7 +3539,6 @@ impl ProtocolConfig {
                     // native function on mainnet.
                     cfg.feature_flags.enable_nitro_attestation_upgraded_parsing = true;
                     cfg.feature_flags.enable_nitro_attestation = true;
-                    cfg.feature_flags.type_tags_in_object_runtime = true;
                 }
                 // Use this template when making changes:
                 //

crates/sui-adapter-transactional-tests/tests/init/emit_event.move

@@ -90,7 +90,6 @@ feature_flags:
   enforce_checkpoint_timestamp_monotonicity: true
   max_ptb_value_size_v2: true
   resolve_type_input_ids_to_defining_id: true
-  type_tags_in_object_runtime: true
 max_tx_size_bytes: 131072
 max_input_objects: 2048
 max_size_written_objects: 5000000

crates/sui-adapter-transactional-tests/tests/init/emit_event.snap

@@ -92,7 +92,6 @@ feature_flags:
   enforce_checkpoint_timestamp_monotonicity: true
   max_ptb_value_size_v2: true
   resolve_type_input_ids_to_defining_id: true
-  type_tags_in_object_runtime: true
 max_tx_size_bytes: 131072
 max_input_objects: 2048
 max_size_written_objects: 5000000

crates/sui-open-rpc/spec/openrpc.json

@@ -97,7 +97,6 @@ feature_flags:
   enforce_checkpoint_timestamp_monotonicity: true
   max_ptb_value_size_v2: true
   resolve_type_input_ids_to_defining_id: true
-  type_tags_in_object_runtime: true
 max_tx_size_bytes: 131072
 max_input_objects: 2048
 max_size_written_objects: 5000000

crates/sui-protocol-config/src/lib.rs

@@ -20,8 +20,7 @@ use move_core_types::{
 };
 use move_vm_config::runtime::VMRuntimeLimitsConfig;
 use move_vm_types::{
-    data_store::DataStore, loaded_data::runtime_types::Type, natives::function::NativeResult,
-    values::Value,
+    loaded_data::runtime_types::Type, natives::function::NativeResult, values::Value,
 };
 use std::{
     cell::RefCell,
@@ -159,36 +158,6 @@ impl<'b> NativeContext<'_, 'b> {
         }
     }
 
-    // TODO: This is a bit hacky right now since we need to pass the store, however this is only
-    // used in test scenarios so we have some special knowledge that makes this work. In the new VM
-    // however this is _MUCH_ nicer as we don't need to pass the datastore as the VM's linkage
-    // tables must have the type present.
-    pub fn type_tag_to_fully_annotated_layout_for_test_scenario_only(
-        &self,
-        tag: &TypeTag,
-        store: &impl DataStore,
-    ) -> PartialVMResult<A::MoveTypeLayout> {
-        self.resolver
-            .loader()
-            .get_fully_annotated_type_layout(tag, store)
-            .map_err(|e| e.to_partial())
-    }
-
-    // TODO: This is a bit hacky right now since we need to pass the store, however this is only
-    // used in test scenarios so we have some special knowledge that makes this work. In the new VM
-    // however this is _MUCH_ nicer as we don't need to pass the datastore as the VM's linkage
-    // tables must have the type present.
-    pub fn type_tag_to_layout_for_test_scenario_only(
-        &self,
-        tag: &TypeTag,
-        store: &impl DataStore,
-    ) -> PartialVMResult<R::MoveTypeLayout> {
-        self.resolver
-            .loader()
-            .get_type_layout(tag, store)
-            .map_err(|e| e.to_partial())
-    }
-
     pub fn type_to_abilities(&self, ty: &Type) -> PartialVMResult<AbilitySet> {
         self.resolver.loader().abilities(ty)
     }

crates/sui-protocol-config/src/snapshots/sui_protocol_config__test__Mainnet_version_83.snap

@@ -15,10 +15,7 @@ mod checked {
         },
         gas_charger::GasCharger,
         gas_meter::SuiGasMeter,
-        programmable_transactions::{
-            data_store::{PackageStore, SuiDataStore},
-            linkage_view::LinkageView,
-        },
+        programmable_transactions::{data_store::SuiDataStore, linkage_view::LinkageView},
         type_resolver::TypeTagResolver,
     };
     use move_binary_format::{
@@ -62,7 +59,7 @@ mod checked {
         metrics::LimitsMetrics,
         move_package::MovePackage,
         object::{Authenticator, Data, MoveObject, Object, ObjectInner, Owner},
-        storage::DenyListResult,
+        storage::{BackingPackageStore, DenyListResult, PackageObject},
         transaction::{Argument, CallArg, ObjectArg},
     };
     use tracing::instrument;
@@ -288,10 +285,10 @@ mod checked {
                     .unwrap_or(*package_id));
             }
 
-            let move_package = get_package(&self.linkage_view, package_id)
+            let package = package_for_linkage(&self.linkage_view, package_id)
                 .map_err(|e| self.convert_vm_error(e))?;
 
-            self.linkage_view.set_linkage(&move_package)
+            self.linkage_view.set_linkage(package.move_package())
         }
 
         /// Load a type using the context's current session.
@@ -344,12 +341,7 @@ mod checked {
             }
             let new_events = events
                 .into_iter()
-                .map(|(tag, value)| {
-                    let ty = unwrap_type_tag_load(
-                        self.protocol_config,
-                        self.load_type_from_struct(&tag)
-                            .map_err(|e| self.convert_vm_error(e)),
-                    )?;
+                .map(|(ty, tag, value)| {
                     let layout = self
                         .vm
                         .get_runtime()
@@ -712,7 +704,7 @@ mod checked {
             let Self {
                 protocol_config,
                 vm,
-                mut linkage_view,
+                linkage_view,
                 mut native_extensions,
                 tx_context,
                 gas_charger,
@@ -847,6 +839,12 @@ mod checked {
             loaded_runtime_objects.extend(loaded_child_objects);
 
             let mut written_objects = BTreeMap::new();
+            for package in new_packages {
+                let package_obj = Object::new_from_package(package, tx_digest);
+                let id = package_obj.id();
+                created_object_ids.insert(id);
+                written_objects.insert(id, package_obj);
+            }
             for (id, additional_write) in additional_writes {
                 let AdditionalWrite {
                     recipient,
@@ -874,24 +872,7 @@ mod checked {
                 }
             }
 
-            for (id, (recipient, tag, value)) in writes {
-                let ty = unwrap_type_tag_load(
-                    protocol_config,
-                    load_type_from_struct(
-                        vm,
-                        &mut linkage_view,
-                        &new_packages,
-                        &StructTag::from(tag.clone()),
-                    )
-                    .map_err(|e| {
-                        convert_vm_error(
-                            e,
-                            vm,
-                            &linkage_view,
-                            protocol_config.resolve_abort_locations_to_package_id(),
-                        )
-                    }),
-                )?;
+            for (id, (recipient, ty, value)) in writes {
                 let abilities = vm.get_runtime().get_type_abilities(&ty).map_err(|e| {
                     convert_vm_error(
                         e,
@@ -929,13 +910,6 @@ mod checked {
                 written_objects.insert(id, object);
             }
 
-            for package in new_packages {
-                let package_obj = Object::new_from_package(package, tx_digest);
-                let id = package_obj.id();
-                created_object_ids.insert(id);
-                written_objects.insert(id, package_obj);
-            }
-
             // Before finishing, ensure that any shared object taken by value by the transaction is either:
             // 1. Mutated (and still has a shared ownership); or
             // 2. Deleted.
@@ -1049,6 +1023,7 @@ mod checked {
 
         /// Special case errors for type arguments to Move functions
         pub fn convert_type_argument_error(&self, idx: usize, error: VMError) -> ExecutionError {
+            use move_core_types::vm_status::StatusCode;
             use sui_types::execution_status::TypeArgumentError;
             match error.major_status() {
                 StatusCode::NUMBER_OF_TYPE_ARGUMENTS_MISMATCH => {
@@ -1309,17 +1284,22 @@ mod checked {
 
     /// Fetch the package at `package_id` with a view to using it as a link context.  Produces an error
     /// if the object at that ID does not exist, or is not a package.
-    fn get_package(
-        package_store: &dyn PackageStore,
+    fn package_for_linkage(
+        linkage_view: &LinkageView,
         package_id: ObjectID,
-    ) -> VMResult<Rc<MovePackage>> {
-        match package_store.get_package(&package_id) {
+    ) -> VMResult<PackageObject> {
+        use move_binary_format::errors::PartialVMError;
+        use move_core_types::vm_status::StatusCode;
+
+        match linkage_view.get_package_object(&package_id) {
             Ok(Some(package)) => Ok(package),
             Ok(None) => Err(PartialVMError::new(StatusCode::LINKER_ERROR)
                 .with_message(format!("Cannot find link context {package_id} in store"))
                 .finish(Location::Undefined)),
             Err(err) => Err(PartialVMError::new(StatusCode::LINKER_ERROR)
-                .with_message(format!("Error loading {package_id} from store: {err}"))
+                .with_message(format!(
+                    "Error loading link context {package_id} from store: {err}"
+                ))
                 .finish(Location::Undefined)),
         }
     }
@@ -1343,27 +1323,22 @@ mod checked {
 
         // Load the package that the struct is defined in, in storage
         let defining_id = ObjectID::from_address(*address);
-
-        let data_store = SuiDataStore::new(linkage_view, new_packages);
-        let move_package = get_package(&data_store, defining_id)?;
-
-        // Save the link context as we need to set it while loading the struct and we don't want to
-        // clobber it.
-        let saved_linkage = linkage_view.steal_linkage();
+        let package = package_for_linkage(linkage_view, defining_id)?;
 
         // Set the defining package as the link context while loading the
         // struct
         let original_address = linkage_view
-            .set_linkage(&move_package)
-            .expect("Linkage context was just stolen. Therefore must be empty");
+            .set_linkage(package.move_package())
+            .map_err(|e| {
+                PartialVMError::new(StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR)
+                    .with_message(e.to_string())
+                    .finish(Location::Undefined)
+            })?;
 
         let runtime_id = ModuleId::new(original_address, module.clone());
         let data_store = SuiDataStore::new(linkage_view, new_packages);
         let res = vm.get_runtime().load_type(&runtime_id, name, &data_store);
         linkage_view.reset_linkage();
-        linkage_view
-            .restore_linkage(saved_linkage)
-            .expect("Linkage context was just reset. Therefore must be empty");
         let (idx, struct_type) = res?;
 
         // Recursively load type parameters, if necessary
@@ -1732,17 +1707,6 @@ mod checked {
         }
     }
 
-    fn unwrap_type_tag_load(
-        protocol_config: &ProtocolConfig,
-        ty: Result<Type, ExecutionError>,
-    ) -> Result<Type, ExecutionError> {
-        if ty.is_err() && !protocol_config.type_tags_in_object_runtime() {
-            panic!("Failed to load a type tag from the object runtime -- this shouldn't happen")
-        } else {
-            ty
-        }
-    }
-
     enum EitherError {
         CommandArgument(CommandArgumentError),
         Execution(ExecutionError),