Create a LayoutResolver to compute layout from VM types

- Move expensive_check_sui_conservation to node init
- Expose a layout resolver based on a VM session
- Decouple MoveResolver traits from Storage traits

In some of the places where we want to use the layout resolver, we
don't have access to all the information to implement `StorageView`,
but we only need to use the `BackingPackageStore`.

To support these cases, we need to provide a state view to
`LinkageView` that can serve packages, and then shim the Module and
Resource resolution functions.

This requires that `LinkageView` no longer accept a reference
parameter, but a value (so we can inject state into it) -- similar to
the trick we pulled to allow `Session` to own a `LinkageView`.  Then
implementors (like `TemporaryStore`) that only need to be passed by
reference can be passed by explicit reference,

i.e. `LinkageView<'state, TemporaryStore>` becomes
`LinkageView<&'state TemporaryStore>`.

However, we cannot impose a `&'state S: StorageView` bound, because
some APIs in `StorageView` require a mutable reference, so we needed
to decouple the resolution traits (now `SuiResolver`) and the storage
traits, to impose twin constraints:

```
fn ...<'state, S>
where
  S: StorageView
  &'state S: SuiResolver
```

- Logging improvements
- Bring `invariant_violation!` macro into `sui-types`.
- Create a variant of it -- `make_invariant_violation!` -- that
  creates the error, but does not wrap it in a result of return it.
- Add `format!` string support to these macros
- Use this macro for invariant violations within conservation checking
  with extra context on what is failing (what stage, what type is
  involved)
- Enable telemetry_subscription in the `move_package_upgrade_tests` to
  see the logs from authorities during tests.
- (Temporary) Print the IDs of published/upgraded packages in the
  failing test, for context.

crates/sui-adapter/src/execution_engine.rs

@@ -22,6 +22,7 @@ use sui_types::programmable_transaction_builder::ProgrammableTransactionBuilder;
 use tracing::{info, instrument, trace, warn};
 
 use crate::programmable_transactions;
+use crate::type_layout_resolver::TypeLayoutResolver;
 use move_binary_format::access::ModuleAccess;
 use sui_macros::checked_arithmetic;
 use sui_protocol_config::{check_limit_by_meter, LimitThresholdCrossed, ProtocolConfig};
@@ -413,18 +414,19 @@ fn execute_transaction<
         temporary_store.conserve_unmetered_storage_rebate(gas_status.unmetered_storage_rebate());
         if !is_genesis_tx && !Mode::allow_arbitrary_values() {
             // ensure that this transaction did not create or destroy SUI, try to recover if the check fails
-            let conservation_result = temporary_store
-                .check_sui_conserved(advance_epoch_gas_summary, enable_expensive_checks);
+            let conservation_result = {
+                let mut layout_resolver = TypeLayoutResolver::new(move_vm, &*temporary_store);
+                temporary_store.check_sui_conserved(advance_epoch_gas_summary, &mut layout_resolver, enable_expensive_checks)
+            };
             if let Err(conservation_err) = conservation_result {
                 // conservation violated. try to avoid panic by dumping all writes, charging for gas, re-checking
                 // conservation, and surfacing an aborted transaction with an invariant violation if all of that works
                 result = Err(conservation_err);
                 temporary_store.reset(gas, &mut gas_status);
                 temporary_store.charge_gas(gas_object_id, &mut gas_status, &mut result, gas);
                 // check conservation once more more
-                if let Err(recovery_err) = temporary_store
-                    .check_sui_conserved(advance_epoch_gas_summary, enable_expensive_checks)
-                {
+                let mut layout_resolver = TypeLayoutResolver::new(move_vm, &*temporary_store);
+                if let Err(recovery_err) = temporary_store.check_sui_conserved(advance_epoch_gas_summary, &mut layout_resolver, enable_expensive_checks) {
                     // if we still fail, it's a problem with gas
                     // charging that happens even in the "aborted" case--no other option but panic.
                     // we will create or destroy SUI otherwise

crates/sui-adapter/src/execution_mode.rs

@@ -6,7 +6,7 @@ use sui_types::{error::ExecutionError, transaction::Argument};
 
 use crate::programmable_transactions::{
     context::ExecutionContext,
-    types::{RawValueType, StorageView, Value},
+    types::{RawValueType, StorageView, SuiResolver, Value},
 };
 
 pub type TransactionIndex = usize;
@@ -32,19 +32,23 @@ pub trait ExecutionMode {
 
     fn empty_results() -> Self::ExecutionResults;
 
-    fn add_argument_update<S: StorageView>(
-        context: &mut ExecutionContext<S>,
+    fn add_argument_update<'vm, 'state, 'a, S: StorageView>(
+        context: &mut ExecutionContext<'vm, 'state, 'a, S>,
         acc: &mut Self::ArgumentUpdates,
         arg: Argument,
         _new_value: &Value,
-    ) -> Result<(), ExecutionError>;
+    ) -> Result<(), ExecutionError>
+    where
+        &'state S: SuiResolver;
 
-    fn finish_command<S: StorageView>(
-        context: &mut ExecutionContext<S>,
+    fn finish_command<'vm, 'state, 'a, S: StorageView>(
+        context: &mut ExecutionContext<'vm, 'state, 'a, S>,
         acc: &mut Self::ExecutionResults,
         argument_updates: Self::ArgumentUpdates,
         command_result: &[Value],
-    ) -> Result<(), ExecutionError>;
+    ) -> Result<(), ExecutionError>
+    where
+        &'state S: SuiResolver;
 }
 
 #[derive(Copy, Clone)]
@@ -70,21 +74,27 @@ impl ExecutionMode for Normal {
 
     fn empty_results() -> Self::ExecutionResults {}
 
-    fn add_argument_update<S: StorageView>(
-        _context: &mut ExecutionContext<S>,
+    fn add_argument_update<'vm, 'state, 'a, S: StorageView>(
+        _context: &mut ExecutionContext<'vm, 'state, 'a, S>,
         _acc: &mut Self::ArgumentUpdates,
         _arg: Argument,
         _new_value: &Value,
-    ) -> Result<(), ExecutionError> {
+    ) -> Result<(), ExecutionError>
+    where
+        &'state S: SuiResolver,
+    {
         Ok(())
     }
 
-    fn finish_command<S: StorageView>(
-        _context: &mut ExecutionContext<S>,
+    fn finish_command<'vm, 'state, 'a, S: StorageView>(
+        _context: &mut ExecutionContext<'vm, 'state, 'a, S>,
         _acc: &mut Self::ExecutionResults,
         _argument_updates: Self::ArgumentUpdates,
         _command_result: &[Value],
-    ) -> Result<(), ExecutionError> {
+    ) -> Result<(), ExecutionError>
+    where
+        &'state S: SuiResolver,
+    {
         Ok(())
     }
 }
@@ -112,21 +122,27 @@ impl ExecutionMode for Genesis {
 
     fn empty_results() -> Self::ExecutionResults {}
 
-    fn add_argument_update<S: StorageView>(
-        _context: &mut ExecutionContext<S>,
+    fn add_argument_update<'vm, 'state, 'a, S: StorageView>(
+        _context: &mut ExecutionContext<'vm, 'state, 'a, S>,
         _acc: &mut Self::ArgumentUpdates,
         _arg: Argument,
         _new_value: &Value,
-    ) -> Result<(), ExecutionError> {
+    ) -> Result<(), ExecutionError>
+    where
+        &'state S: SuiResolver,
+    {
         Ok(())
     }
 
-    fn finish_command<S: StorageView>(
-        _context: &mut ExecutionContext<S>,
+    fn finish_command<'vm, 'state, 'a, S: StorageView>(
+        _context: &mut ExecutionContext<'vm, 'state, 'a, S>,
         _acc: &mut Self::ExecutionResults,
         _argument_updates: Self::ArgumentUpdates,
         _command_result: &[Value],
-    ) -> Result<(), ExecutionError> {
+    ) -> Result<(), ExecutionError>
+    where
+        &'state S: SuiResolver,
+    {
         Ok(())
     }
 }
@@ -157,21 +173,27 @@ impl ExecutionMode for System {
 
     fn empty_results() -> Self::ExecutionResults {}
 
-    fn add_argument_update<S: StorageView>(
-        _context: &mut ExecutionContext<S>,
+    fn add_argument_update<'vm, 'state, 'a, S: StorageView>(
+        _context: &mut ExecutionContext<'vm, 'state, 'a, S>,
         _acc: &mut Self::ArgumentUpdates,
         _arg: Argument,
         _new_value: &Value,
-    ) -> Result<(), ExecutionError> {
+    ) -> Result<(), ExecutionError>
+    where
+        &'state S: SuiResolver,
+    {
         Ok(())
     }
 
-    fn finish_command<S: StorageView>(
-        _context: &mut ExecutionContext<S>,
+    fn finish_command<'vm, 'state, 'a, S: StorageView>(
+        _context: &mut ExecutionContext<'vm, 'state, 'a, S>,
         _acc: &mut Self::ExecutionResults,
         _argument_updates: Self::ArgumentUpdates,
         _command_result: &[Value],
-    ) -> Result<(), ExecutionError> {
+    ) -> Result<(), ExecutionError>
+    where
+        &'state S: SuiResolver,
+    {
         Ok(())
     }
 }
@@ -210,23 +232,29 @@ impl ExecutionMode for DevInspect {
         vec![]
     }
 
-    fn add_argument_update<S: StorageView>(
-        context: &mut ExecutionContext<S>,
+    fn add_argument_update<'vm, 'state, 'a, S: StorageView>(
+        context: &mut ExecutionContext<'vm, 'state, 'a, S>,
         acc: &mut Self::ArgumentUpdates,
         arg: Argument,
         new_value: &Value,
-    ) -> Result<(), ExecutionError> {
+    ) -> Result<(), ExecutionError>
+    where
+        &'state S: SuiResolver,
+    {
         let (bytes, type_tag) = value_to_bytes_and_tag(context, new_value)?;
         acc.push((arg, bytes, type_tag));
         Ok(())
     }
 
-    fn finish_command<S: StorageView>(
-        context: &mut ExecutionContext<S>,
+    fn finish_command<'vm, 'state, 'a, S: StorageView>(
+        context: &mut ExecutionContext<'vm, 'state, 'a, S>,
         acc: &mut Self::ExecutionResults,
         argument_updates: Self::ArgumentUpdates,
         command_result: &[Value],
-    ) -> Result<(), ExecutionError> {
+    ) -> Result<(), ExecutionError>
+    where
+        &'state S: SuiResolver,
+    {
         let command_bytes = command_result
             .iter()
             .map(|value| value_to_bytes_and_tag(context, value))
@@ -236,10 +264,13 @@ impl ExecutionMode for DevInspect {
     }
 }
 
-fn value_to_bytes_and_tag<S: StorageView>(
-    context: &mut ExecutionContext<S>,
+fn value_to_bytes_and_tag<'vm, 'state, 'a, S: StorageView>(
+    context: &mut ExecutionContext<'vm, 'state, 'a, S>,
     value: &Value,
-) -> Result<(Vec<u8>, TypeTag), ExecutionError> {
+) -> Result<(Vec<u8>, TypeTag), ExecutionError>
+where
+    &'state S: SuiResolver,
+{
     let (type_tag, bytes) = match value {
         Value::Object(obj) => {
             let tag = context

crates/sui-adapter/src/lib.rs

@@ -1,25 +1,12 @@
 // Copyright (c) Mysten Labs, Inc.
 // SPDX-License-Identifier: Apache-2.0
 
-macro_rules! invariant_violation {
-    ($msg:expr) => {{
-        if cfg!(debug_assertions) {
-            panic!("{}", $msg)
-        }
-        return Err(sui_types::error::ExecutionError::invariant_violation($msg).into());
-    }};
-}
-
-macro_rules! assert_invariant {
-    ($cond:expr, $msg:expr) => {{
-        if !$cond {
-            invariant_violation!($msg)
-        }
-    }};
-}
+#[macro_use]
+extern crate sui_types;
 
 pub mod adapter;
 pub mod error;
 pub mod execution_engine;
 pub mod execution_mode;
 pub mod programmable_transactions;
+pub mod type_layout_resolver;