partial cheat scenario impl

Author: wtdcode

Cargo.lock

@@ -8,7 +8,7 @@ use move_vm_runtime::move_vm::MoveVM;
 use movy_sui::{
     cheats::{all_cheates, backend::CheatBackend},
     compile::SuiCompiledPackage,
-    database::cache::ObjectSuiStoreCommit,
+    database::cache::{CachedSnapshot, ObjectSuiStoreCommit},
 };
 use movy_types::{error::MovyError, object::MoveOwner};
 use sui_move_natives_latest::all_natives;
@@ -43,7 +43,7 @@ pub fn testing_proto() -> ProtocolConfig {
 #[derive(Clone)]
 pub struct SuiExecutor<T> {
     pub db: T,
-    pub cheat_backend: CheatBackend<T>,
+    pub cheat_backend: CheatBackend,
     pub protocol_config: ProtocolConfig,
     pub metrics: Arc<LimitsMetrics>,
     pub registry: prometheus::Registry,
@@ -70,19 +70,13 @@ impl<R> Deref for ExecutionTracedResults<R> {
 
 impl<T> SuiExecutor<T>
 where
-    T: ObjectStore
-        + BackingStore
-        + ObjectSuiStoreCommit
-        + ObjectStoreMintObject
-        + ObjectStoreInfo
-        + Clone
-        + 'static,
+    T: ObjectStore + BackingStore + ObjectSuiStoreCommit + ObjectStoreMintObject + ObjectStoreInfo,
 {
-    pub fn new(db: T) -> Result<Self, MovyError> {
+    pub fn new_with_cheats_storage(db: T, storage: CachedSnapshot) -> Result<Self, MovyError> {
         let protocol_config = testing_proto();
         let registry = prometheus::Registry::new();
         let metrics = Arc::new(LimitsMetrics::new(&registry));
-        let (cheat_backend, cheats) = all_cheates(db.clone());
+        let (cheat_backend, cheats) = all_cheates(storage);
         let movevm = Arc::new(
             MoveVM::new(
                 all_natives(false, &protocol_config)
@@ -100,6 +94,9 @@ where
             movevm,
         })
     }
+    pub fn new(db: T) -> Result<Self, MovyError> {
+        Self::new_with_cheats_storage(db, CachedSnapshot::default())
+    }
 
     pub fn run_tx_trace<R: Tracer>(
         &self,

crates/movy-replay/src/exec.rs

@@ -1,9 +1,42 @@
 module movy::cheats;
 
 use sui::tx_context::TxContext;
+use sui::vec_map::VecMap;
 
 const TX_HASH_LENGTH: u64 = 32;
 
+
+/// Attempted to return an object to the inventory that was not previously removed from the
+/// inventory during the current transaction. Can happen if the user attempts to call
+/// `return_to_address` on a locally constructed object rather than one returned from a
+/// `test_scenario` function such as `take_from_address`.
+const ECantReturnObject: u64 = 2;
+
+/// Attempted to retrieve an object of a particular type from the inventory, but it is empty.
+/// Can happen if the user already transferred the object or a previous transaction failed to
+/// transfer the object to the user.
+const EEmptyInventory: u64 = 3;
+
+/// The effects of a transaction
+public struct TransactionEffects has drop {
+    /// The objects created this transaction
+    created: vector<ID>,
+    /// The objects written/modified this transaction
+    written: vector<ID>,
+    /// The objects deleted this transaction
+    deleted: vector<ID>,
+    /// The objects transferred to an account this transaction
+    transferred_to_account: VecMap<ID, /* owner */ address>,
+    /// The objects transferred to an object this transaction
+    transferred_to_object: VecMap<ID, /* owner */ ID>,
+    /// The objects shared this transaction
+    shared: vector<ID>,
+    /// The objects frozen this transaction
+    frozen: vector<ID>,
+    /// The number of user events emitted this transaction
+    num_user_events: u64,
+}
+
 /// A cheat scenario for mocking a multi-transaction Sui execution
 public struct CheatScenario {
     txn_number: u64,
@@ -18,11 +51,15 @@ public fun begin(sender: address): CheatScenario {
     }
 }
 
+public fun ctx(scenario: &mut CheatScenario): &mut TxContext {
+    &mut scenario.ctx
+}
+
 /// Ends the test scenario
 /// Returns the results from the final transaction
 /// Will abort if shared or immutable objects were deleted, transferred, or wrapped.
 /// Will abort if TransactionEffects cannot be generated
-public fun end(scenario: CheatScenario) {
+public fun end(scenario: CheatScenario): TransactionEffects {
     let CheatScenario { txn_number: _, ctx: _ } = scenario;
     end_transaction()
 }
@@ -36,7 +73,7 @@ public fun end(scenario: CheatScenario) {
 /// Returns the results from the previous transaction
 /// Will abort if shared or immutable objects were deleted, transferred, or wrapped.
 /// Will abort if TransactionEffects cannot be generated
-public fun next_tx(scenario: &mut CheatScenario, sender: address) {
+public fun next_tx(scenario: &mut CheatScenario, sender: address): TransactionEffects {
     // create a seed for new transaction digest to ensure that this tx has a different
     // digest (and consequently, different object ID's) than the previous tx
     scenario.txn_number = scenario.txn_number + 1;
@@ -105,16 +142,34 @@ native fun new_tx_context(
     ids_created: u64
 ): TxContext;
 
+/// Helper combining `take_shared_by_id` and `most_recent_id_shared`
+/// Aborts if there is no shared object of type `T` in the global inventory
+public fun take_shared<T: key>(): T {
+    let id_opt = most_recent_id_shared<T>();
+    assert!(id_opt.is_some(), EEmptyInventory);
+    take_by_id(id_opt.destroy_some())
+}
+
+/// Return `t` to the global inventory
+public fun return_shared<T: key>(t: T) {
+    let id = object::id(&t);
+    assert!(was_taken_shared(id), ECantReturnObject);
+    share_object_impl(t)
+}
+
+
+native fun was_taken_shared(id: ID): bool;
+native fun most_recent_id_shared<T: key>(): Option<ID>;
+
 // native fun objects_by_type<T: key>(): vector<ID>;
 
 native fun take_by_id<T: key>(id: ID): T;
 
 // Forward to sui std native call
-// native fun share_object_impl<T: key>(obj: T);
-
+native fun share_object_impl<T: key>(obj: T);
 // native fun freeze_object_impl<T: key>(obj: T);
 
-native fun end_transaction();
+native fun end_transaction(): TransactionEffects;
 
 // public fun return_shared<T: key>(t: T) {
 //     share_object_impl(t)

crates/movy-sui-stds/movy/sources/cheats.move

@@ -43,6 +43,7 @@ sui-rpc = {workspace = true}
 sui-sdk-types = {workspace = true}
 shared-crypto = {workspace = true}
 sui-sdk = {workspace = true}
+sui-move-natives-latest = {workspace = true}
 
 movy-types = {workspace = true}
 

crates/movy-sui/Cargo.toml

@@ -1,13 +1,43 @@
-use std::{cell::UnsafeCell, sync::Arc};
+use std::{
+    cell::UnsafeCell,
+    collections::{BTreeMap, BTreeSet},
+    sync::Arc,
+};
+
+use sui_types::{
+    TypeTag,
+    base_types::{MoveObjectType, ObjectID},
+};
+
+use crate::database::cache::CachedSnapshot;
 
 // CheatBackend is a global backend that a Move VM globally holds
-pub struct CheatBackendInner<T> {
-    pub db: T,
+pub struct CheatBackendInner {
+    pub storage: CachedSnapshot,
+    pub tys: BTreeMap<MoveObjectType, BTreeSet<ObjectID>>,
+    pub latest_objects_by_types: BTreeMap<MoveObjectType, ObjectID>,
+    pub taken: BTreeSet<ObjectID>,
 }
 
-impl<T> CheatBackendInner<T> {
-    pub fn new(db: T) -> Self {
-        Self { db }
+impl CheatBackendInner {
+    pub fn new(storage: CachedSnapshot) -> Self {
+        let mut tys: BTreeMap<MoveObjectType, BTreeSet<ObjectID>> = BTreeMap::new();
+
+        for (id, mp) in storage.objects.iter() {
+            for (_, obj) in mp.iter() {
+                if let Some(obj) = obj {
+                    if let Some(ty) = obj.type_() {
+                        tys.entry(ty.clone()).or_default().insert(*id);
+                    }
+                }
+            }
+        }
+        Self {
+            storage,
+            tys,
+            latest_objects_by_types: BTreeMap::new(),
+            taken: BTreeSet::new(),
+        }
     }
 
     // Must be called before every ptb execution
@@ -18,11 +48,11 @@ impl<T> CheatBackendInner<T> {
 
 // Tight wrapper of CheatBackendInner to satisfy the contract of Sui natives
 // Note it is ub to call cheat backend concurrently.
-pub struct CheatBackend<T> {
-    inner: Arc<UnsafeCell<CheatBackendInner<T>>>,
+pub struct CheatBackend {
+    inner: Arc<UnsafeCell<CheatBackendInner>>,
 }
 
-impl<T> Clone for CheatBackend<T> {
+impl Clone for CheatBackend {
     fn clone(&self) -> Self {
         Self {
             inner: self.inner.clone(),
@@ -31,22 +61,22 @@ impl<T> Clone for CheatBackend<T> {
 }
 
 // SAFETY: We guarantee single-threaded access
-unsafe impl<T> Send for CheatBackend<T> {}
-unsafe impl<T> Sync for CheatBackend<T> {}
+unsafe impl Send for CheatBackend {}
+unsafe impl Sync for CheatBackend {}
 
-impl<T> CheatBackend<T> {
-    pub fn new(db: T) -> Self {
+impl CheatBackend {
+    pub fn new(storage: CachedSnapshot) -> Self {
         Self {
-            inner: Arc::new(UnsafeCell::new(CheatBackendInner::new(db))),
+            inner: Arc::new(UnsafeCell::new(CheatBackendInner::new(storage))),
         }
     }
 
-    pub fn inner(&self) -> &CheatBackendInner<T> {
+    pub fn inner(&self) -> &CheatBackendInner {
         // SAFETY: No concurrent access exists by design.
         unsafe { &*self.inner.get() }
     }
 
-    pub fn inner_mut(&self) -> &mut CheatBackendInner<T> {
+    pub fn inner_mut(&self) -> &mut CheatBackendInner {
         // SAFETY: No concurrent access exists by design.
         unsafe { &mut *self.inner.get() }
     }

crates/movy-sui/src/cheats/backend.rs

@@ -4,7 +4,7 @@ use move_core_types::account_address::AccountAddress;
 use move_vm_runtime::native_functions::NativeFunctionTable;
 use sui_types::Identifier;
 
-use crate::cheats::backend::CheatBackend;
+use crate::{cheats::backend::CheatBackend, database::cache::CachedSnapshot};
 
 pub mod backend;
 pub mod ctx;
@@ -55,11 +55,8 @@ pub fn cheat_address() -> &'static AccountAddress {
     &CHEAT
 }
 
-pub fn all_cheates<T>(db: T) -> (CheatBackend<T>, NativeFunctionTable)
-where
-    T: 'static,
-{
-    let backend = CheatBackend::new(db);
+pub fn all_cheates(storage: CachedSnapshot) -> (CheatBackend, NativeFunctionTable) {
+    let backend = CheatBackend::new(storage);
     (
         backend.clone(),
         vec![
@@ -68,6 +65,12 @@ where
                 "new_tx_context",
                 super::cheats::ctx::new_tx_context
             ),
+            make_backend_cheat!(
+                backend,
+                "cheats",
+                "share_object_impl",
+                super::cheats::scenario::share_object_impl
+            ),
             make_backend_cheat!(
                 backend,
                 "cheats",

crates/movy-sui/src/cheats/mod.rs

@@ -1,26 +1,87 @@
 use std::collections::VecDeque;
 
-use move_binary_format::errors::PartialVMResult;
-use move_core_types::gas_algebra::InternalGas;
+use move_binary_format::errors::{PartialVMError, PartialVMResult};
+use move_core_types::{
+    account_address::AccountAddress, gas_algebra::InternalGas, vm_status::StatusCode,
+};
 use move_vm_runtime::native_functions::NativeContext;
 use move_vm_types::{
     loaded_data::runtime_types::Type, natives::function::NativeResult, values::Value,
 };
+use sui_move_natives_latest::get_nth_struct_field;
+use sui_types::{
+    TypeTag,
+    base_types::{MoveObjectType, ObjectID},
+};
 
 use crate::cheats::backend::CheatBackend;
 
-// pub fn take_by_id<T>(db: T, _ctx: &NativeContext, tys: Vec<Type>, vals: VecDeque<Value>) -> PartialVMResult<NativeResult>
-// {
+fn get_specified_ty(mut ty_args: Vec<Type>) -> Type {
+    assert!(ty_args.len() == 1);
+    ty_args.pop().unwrap()
+}
+
+fn pop_id(args: &mut VecDeque<Value>) -> PartialVMResult<ObjectID> {
+    let v = match args.pop_back() {
+        None => {
+            return Err(PartialVMError::new(
+                StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR,
+            ));
+        }
+        Some(v) => v,
+    };
+    Ok(get_nth_struct_field(v, 0)?
+        .value_as::<AccountAddress>()?
+        .into())
+}
+
+fn object_type_of_type(context: &NativeContext, ty: &Type) -> PartialVMResult<MoveObjectType> {
+    let TypeTag::Struct(s_tag) = context.type_to_type_tag(ty)? else {
+        return Err(PartialVMError::new(
+            StatusCode::UNKNOWN_INVARIANT_VIOLATION_ERROR,
+        ));
+    };
+    Ok(MoveObjectType::from(*s_tag))
+}
+
+// native fun was_taken_shared(id: ID): bool;
+// native fun most_recent_id_shared<T: key>(): Option<ID>;
 
-// }
+// // native fun objects_by_type<T: key>(): vector<ID>;
+
+// // Forward to sui std native call
+// native fun share_object_impl<T: key>(obj: T);
+pub fn share_object_impl(
+    _backend: &CheatBackend,
+    ctx: &mut NativeContext,
+    tys: Vec<Type>,
+    vals: VecDeque<Value>,
+) -> PartialVMResult<NativeResult> {
+    sui_move_natives_latest::transfer::share_object(ctx, tys, vals)
+}
+
+// // native fun freeze_object_impl<T: key>(obj: T); // TODO
+
+// native fun take_by_id<T: key>(id: ID): T;
+pub fn take_by_id(
+    backend: &CheatBackend,
+    ctx: &mut NativeContext,
+    tys: Vec<Type>,
+    mut vals: VecDeque<Value>,
+) -> PartialVMResult<NativeResult> {
+    let ty = get_specified_ty(tys);
+    let id = pop_id(vals)?;
+    let specified_obj_ty = object_type_of_type(ctx, &ty)?;
+    // TODO
+    PartialVMResult::Ok(NativeResult::ok(InternalGas::zero(), vec![].into()))
+}
 
 // native fun end_transaction();
-pub fn end_transaction<T>(
-    backend: &CheatBackend<T>,
-    _ctx: &NativeContext,
+pub fn end_transaction(
+    backend: &CheatBackend,
+    _ctx: &mut NativeContext,
     _tys: Vec<Type>,
     _vals: VecDeque<Value>,
 ) -> PartialVMResult<NativeResult> {
-    backend.inner_mut().end_transaction();
     PartialVMResult::Ok(NativeResult::ok(InternalGas::zero(), vec![].into()))
 }