sui_types/storage/

mod.rs

// Copyright (c) Mysten Labs, Inc.
// SPDX-License-Identifier: Apache-2.0

pub mod error;
mod object_store_trait;
mod read_store;
mod shared_in_memory_store;
mod write_store;

use crate::IMPLICITLY_READ_SYSTEM_OBJECTS;
use crate::base_types::{
    ConsensusObjectSequenceKey, ConsensusObjectVersion, FullObjectID, FullObjectRef, SuiAddress,
    SystemObjectVersions, TransactionDigest, VersionNumber,
};
use crate::committee::EpochId;
use crate::effects::{TransactionEffects, TransactionEffectsAPI};
use crate::error::{ExecutionError, SuiError, SuiErrorKind};
use crate::execution::{DynamicallyLoadedObjectMetadata, ExecutionResults};
use crate::full_checkpoint_content::ObjectSet;
use crate::message_envelope::Message;
use crate::move_package::MovePackage;
use crate::storage::error::Error as StorageError;
use crate::transaction::TransactionData;
use crate::transaction::{InputObjects, SenderSignedData, TransactionDataAPI};
use crate::{
    base_types::{ObjectID, ObjectRef, SequenceNumber},
    error::SuiResult,
    object::Object,
};
use itertools::Itertools;
use move_binary_format::CompiledModule;
use move_core_types::language_storage::{ModuleId, TypeTag};
use move_core_types::resolver::SerializedPackage;
pub use object_store_trait::ObjectStore;
pub use read_store::BalanceInfo;
pub use read_store::BalanceIterator;
pub use read_store::CoinInfo;
pub use read_store::DynamicFieldIndexInfo;
pub use read_store::DynamicFieldIteratorItem;
pub use read_store::DynamicFieldKey;
pub use read_store::EpochInfo;
pub use read_store::LedgerBitmapBucket;
pub use read_store::LedgerBitmapBucketIter;
pub use read_store::LedgerBitmapBucketIterator;
pub use read_store::LedgerTxSeqDigest;
pub use read_store::LedgerTxSeqDigestIterator;
pub use read_store::OwnedObjectInfo;
pub use read_store::ReadStore;
pub use read_store::RpcIndexes;
pub use read_store::RpcStateReader;
pub use read_store::TransactionInfo;
use serde::{Deserialize, Serialize};
use serde_with::serde_as;
pub use shared_in_memory_store::SharedInMemoryStore;
pub use shared_in_memory_store::SingleCheckpointSharedInMemoryStore;
use std::collections::{BTreeMap, BTreeSet};
use std::fmt::{Display, Formatter};
use std::sync::Arc;
pub use write_store::WriteStore;

/// A potential input to a transaction.
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub enum InputKey {
    VersionedObject {
        id: FullObjectID,
        version: SequenceNumber,
    },
    Package {
        id: ObjectID,
    },
}

impl InputKey {
    pub fn id(&self) -> FullObjectID {
        match self {
            InputKey::VersionedObject { id, .. } => *id,
            InputKey::Package { id } => FullObjectID::Fastpath(*id),
        }
    }

    pub fn version(&self) -> Option<SequenceNumber> {
        match self {
            InputKey::VersionedObject { version, .. } => Some(*version),
            InputKey::Package { .. } => None,
        }
    }

    pub fn is_cancelled(&self) -> bool {
        match self {
            InputKey::VersionedObject { version, .. } => version.is_cancelled(),
            InputKey::Package { .. } => false,
        }
    }
}

impl From<&Object> for InputKey {
    fn from(obj: &Object) -> Self {
        if obj.is_package() {
            InputKey::Package { id: obj.id() }
        } else {
            InputKey::VersionedObject {
                id: obj.full_id(),
                version: obj.version(),
            }
        }
    }
}

#[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize, Deserialize)]
pub enum WriteKind {
    /// The object was in storage already but has been modified
    Mutate,
    /// The object was created in this transaction
    Create,
    /// The object was previously wrapped in another object, but has been restored to storage
    Unwrap,
}

#[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize, Deserialize)]
pub enum DeleteKind {
    /// An object is provided in the call input, and gets deleted.
    Normal,
    /// An object is not provided in the call input, but gets unwrapped
    /// from another object, and then gets deleted.
    UnwrapThenDelete,
    /// An object is provided in the call input, and gets wrapped into another object.
    Wrap,
}

#[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize, Deserialize)]
pub enum MarkerValue {
    /// An object was received at the given version in the transaction and is no longer able
    /// to be received at that version in subequent transactions.
    Received,
    /// A fastpath object was deleted, wrapped, or transferred to consensus at the given
    /// version, and is no longer able to be accessed or used in subsequent transactions via
    /// fastpath unless/until it is returned to fastpath.
    FastpathStreamEnded,
    /// A consensus object was deleted or removed from consensus by the transaction and is no longer
    /// able to be accessed or used in subsequent transactions with the same initial shared version.
    ConsensusStreamEnded(TransactionDigest),
}

/// DeleteKind together with the old sequence number prior to the deletion, if available.
/// For normal deletion and wrap, we always will consult the object store to obtain the old sequence number.
/// For UnwrapThenDelete however, in the old protocol where simplified_unwrap_then_delete is false,
/// we will consult the object store to obtain the old sequence number, which latter will be put in
/// modified_at_versions; in the new protocol where simplified_unwrap_then_delete is true,
/// we will not consult the object store, and hence won't have the old sequence number.
#[derive(Debug)]
pub enum DeleteKindWithOldVersion {
    Normal(SequenceNumber),
    // This variant will be deprecated when we turn on simplified_unwrap_then_delete.
    UnwrapThenDeleteDEPRECATED(SequenceNumber),
    UnwrapThenDelete,
    Wrap(SequenceNumber),
}

impl DeleteKindWithOldVersion {
    pub fn old_version(&self) -> Option<SequenceNumber> {
        match self {
            DeleteKindWithOldVersion::Normal(version)
            | DeleteKindWithOldVersion::UnwrapThenDeleteDEPRECATED(version)
            | DeleteKindWithOldVersion::Wrap(version) => Some(*version),
            DeleteKindWithOldVersion::UnwrapThenDelete => None,
        }
    }

    pub fn to_delete_kind(&self) -> DeleteKind {
        match self {
            DeleteKindWithOldVersion::Normal(_) => DeleteKind::Normal,
            DeleteKindWithOldVersion::UnwrapThenDeleteDEPRECATED(_)
            | DeleteKindWithOldVersion::UnwrapThenDelete => DeleteKind::UnwrapThenDelete,
            DeleteKindWithOldVersion::Wrap(_) => DeleteKind::Wrap,
        }
    }
}

#[derive(Debug)]
pub enum ObjectChange {
    Write(Object, WriteKind),
    // DeleteKind together with the old sequence number prior to the deletion, if available.
    Delete(DeleteKindWithOldVersion),
}

pub trait StorageView: Storage + ParentSync + RuntimeObjectResolver {}
impl<T: Storage + ParentSync + RuntimeObjectResolver> StorageView for T {}

#[derive(Debug, Clone, PartialEq, Eq)]
#[must_use]
pub enum ObjectFundsSufficiency {
    Sufficient,
    Insufficient,
    Overflow,
    LoadError(String),
}

/// An abstraction of the (possibly distributed) store for objects. This
/// API only allows for the retrieval of objects, not any state changes
pub trait RuntimeObjectResolver: BackingPackageStore {
    /// `child` must have an `ObjectOwner` ownership equal to `owner`.
    fn read_child_object(
        &self,
        parent: &ObjectID,
        child: &ObjectID,
        child_version_upper_bound: SequenceNumber,
    ) -> SuiResult<Option<Object>>;

    /// `receiving_object_id` must have an `AddressOwner` ownership equal to `owner`.
    /// `get_object_received_at_version` must be the exact version at which the object will be received,
    /// and it cannot have been previously received at that version. NB: An object not existing at
    /// that version, and not having valid access to the object will be treated exactly the same
    /// and `Ok(None)` must be returned.
    fn get_object_received_at_version(
        &self,
        owner: &ObjectID,
        receiving_object_id: &ObjectID,
        receive_object_at_version: SequenceNumber,
        epoch_id: EpochId,
    ) -> SuiResult<Option<Object>>;

    /// Get's the package at the given version. Returns `Some(package)` only if the `package_id` is
    /// a `MovePackage` with the given `package_version`. Returns `None` in all other cases.
    ///
    /// Since the has the _possibility_ of doing unsequenced reads of object IDs it is important
    /// here that:
    /// * If the package object does not exist; or
    /// * If the package object exists but is not a Move package; or
    /// * If the package object exists and is a Move package, but the version is not the supplied version.
    ///
    /// All return the same error.
    ///
    /// To be extra careful, we simply return `None` in all cases unless the object is a package
    /// with the exact version supplied, and let the caller decide how to handle it.
    fn get_package_at_version(
        &self,
        package_id: &ObjectID,
        package_version: SequenceNumber,
    ) -> Option<MovePackage> {
        let move_pkg = self
            .get_package_object(package_id)
            .ok()
            .flatten()?
            .into_move_package();
        if move_pkg.version() == package_version {
            Some(move_pkg)
        } else {
            None
        }
    }
}

/// Answers queries against the implicitly read system objects, each read as of the version
/// consensus assigned to this transaction. Never sees writes made earlier in the same transaction.
pub trait ImplicitSystemObjectResolver {
    fn object_available_balance(&self, owner: SuiAddress, type_: &TypeTag) -> SuiResult<u128>;

    fn clock(&self) -> SuiResult<Object>;
}

pub struct DenyListResult {
    /// Ok if all regulated coin owners are allowed.
    /// Err if any regulated coin owner is denied (returning the error for first one denied).
    pub result: Result<(), ExecutionError>,
    /// The number of non-gas-coin owners in the transaction results
    pub num_non_gas_coin_owners: u64,
}

/// An abstraction of the (possibly distributed) store for objects, and (soon) events and transactions
pub trait Storage {
    fn reset(&mut self);

    fn read_object(&self, id: &ObjectID) -> Option<&Object>;

    fn record_execution_results(&mut self, results: ExecutionResults)
    -> Result<(), ExecutionError>;

    fn save_loaded_runtime_objects(
        &mut self,
        loaded_runtime_objects: BTreeMap<ObjectID, DynamicallyLoadedObjectMetadata>,
    );

    fn save_wrapped_object_containers(
        &mut self,
        wrapped_object_containers: BTreeMap<ObjectID, ObjectID>,
    );

    /// Given the set of all coin types and owners that are receiving the coins during execution,
    /// Check coin denylist v2, and return the number of non-gas-coin owners.
    fn check_coin_deny_list(
        &self,
        receiving_funds_type_and_owners: BTreeMap<TypeTag, BTreeSet<SuiAddress>>,
    ) -> DenyListResult;

    fn record_generated_object_ids(&mut self, generated_ids: BTreeSet<ObjectID>);
}

pub type PackageFetchResults<Package> = Result<Vec<Package>, Vec<ObjectID>>;

#[derive(Clone, Debug)]
pub struct PackageObject {
    package_object: Object,
}

impl PackageObject {
    pub fn new(package_object: Object) -> Self {
        assert!(package_object.is_package());
        Self { package_object }
    }

    pub fn object(&self) -> &Object {
        &self.package_object
    }

    pub fn move_package(&self) -> &MovePackage {
        self.package_object.data.try_as_package().unwrap()
    }

    pub fn into_move_package(self) -> MovePackage {
        self.package_object
            .into_inner()
            .data
            .try_into_package()
            .unwrap()
    }
}

impl From<PackageObject> for Object {
    fn from(package_object_arc: PackageObject) -> Self {
        package_object_arc.package_object
    }
}

pub trait BackingPackageStore {
    fn get_package_object(&self, package_id: &ObjectID) -> SuiResult<Option<PackageObject>>;
}

impl<S: ?Sized + BackingPackageStore> BackingPackageStore for Box<S> {
    fn get_package_object(&self, package_id: &ObjectID) -> SuiResult<Option<PackageObject>> {
        BackingPackageStore::get_package_object(self.as_ref(), package_id)
    }
}

impl<S: ?Sized + BackingPackageStore> BackingPackageStore for Arc<S> {
    fn get_package_object(&self, package_id: &ObjectID) -> SuiResult<Option<PackageObject>> {
        BackingPackageStore::get_package_object(self.as_ref(), package_id)
    }
}

impl<S: ?Sized + BackingPackageStore> BackingPackageStore for &S {
    fn get_package_object(&self, package_id: &ObjectID) -> SuiResult<Option<PackageObject>> {
        BackingPackageStore::get_package_object(*self, package_id)
    }
}

impl<S: ?Sized + BackingPackageStore> BackingPackageStore for &mut S {
    fn get_package_object(&self, package_id: &ObjectID) -> SuiResult<Option<PackageObject>> {
        BackingPackageStore::get_package_object(*self, package_id)
    }
}

/// A BackingPackageStore that overlays objects on top of a backing store.
/// This allows resolving packages from a set of objects (e.g., output objects from a transaction)
/// before falling back to the backing store.
pub struct OverlayBackingPackageStore<'a, S> {
    overlay: &'a ObjectSet,
    backing: S,
}

impl<'a, S> OverlayBackingPackageStore<'a, S> {
    pub fn new(overlay: &'a ObjectSet, backing: S) -> Self {
        Self { overlay, backing }
    }
}

impl<S: BackingPackageStore> BackingPackageStore for OverlayBackingPackageStore<'_, S> {
    fn get_package_object(&self, package_id: &ObjectID) -> SuiResult<Option<PackageObject>> {
        // First check the overlay for the object
        for obj in self.overlay.iter() {
            if &obj.id() == package_id {
                // Found in overlay - check if it's a package
                fp_ensure!(
                    obj.is_package(),
                    SuiErrorKind::BadObjectType {
                        error: format!("Package expected, Move object found: {package_id}"),
                    }
                    .into()
                );
                return Ok(Some(PackageObject::new(obj.clone())));
            }
        }
        // Not in overlay, fall back to the backing store
        self.backing.get_package_object(package_id)
    }
}

pub fn load_package_object_from_object_store(
    store: &impl ObjectStore,
    package_id: &ObjectID,
) -> SuiResult<Option<PackageObject>> {
    let package = store.get_object(package_id);
    if let Some(obj) = &package {
        fp_ensure!(
            obj.is_package(),
            SuiErrorKind::BadObjectType {
                error: format!("Package expected, Move object found: {package_id}"),
            }
            .into()
        );
    }
    Ok(package.map(PackageObject::new))
}

/// Returns Ok(<package object for each package id in `package_ids`>) if all package IDs in
/// `package_id` were found. If any package in `package_ids` was not found it returns a list
/// of any package ids that are unable to be found>).
pub fn get_package_objects<'a>(
    store: &impl BackingPackageStore,
    package_ids: impl IntoIterator<Item = &'a ObjectID>,
) -> SuiResult<PackageFetchResults<PackageObject>> {
    let packages: Vec<Result<_, _>> = package_ids
        .into_iter()
        .map(|id| match store.get_package_object(id) {
            Ok(None) => Ok(Err(*id)),
            Ok(Some(o)) => Ok(Ok(o)),
            Err(x) => Err(x),
        })
        .collect::<SuiResult<_>>()?;

    let (fetched, failed_to_fetch): (Vec<_>, Vec<_>) = packages.into_iter().partition_result();
    if !failed_to_fetch.is_empty() {
        Ok(Err(failed_to_fetch))
    } else {
        Ok(Ok(fetched))
    }
}

pub fn get_module(
    store: impl BackingPackageStore,
    module_id: &ModuleId,
) -> Result<Option<Vec<u8>>, SuiError> {
    Ok(store
        .get_package_object(&ObjectID::from(*module_id.address()))?
        .and_then(|package| {
            package
                .move_package()
                .serialized_module_map()
                .get(module_id.name().as_str())
                .cloned()
        }))
}

pub fn get_package(
    store: impl BackingPackageStore,
    id: &ObjectID,
) -> SuiResult<Option<SerializedPackage>> {
    store
        .get_package_object(id)?
        .map(|package| package.move_package().into_serialized_move_package())
        .transpose()
}

pub fn get_module_by_id<S: BackingPackageStore>(
    store: &S,
    id: &ModuleId,
) -> anyhow::Result<Option<CompiledModule>, SuiError> {
    Ok(get_module(store, id)?
        .map(|bytes| CompiledModule::deserialize_with_defaults(&bytes).unwrap()))
}

/// A `BackingPackageStore` that resolves packages from a backing store, but also includes any
/// packages that were published in the current transaction execution. This can be used to resolve
/// Move modules right after transaction execution, but newly published packages have not yet been
/// committed to the backing store on a fullnode.
pub struct PostExecutionPackageResolver {
    backing_store: Arc<dyn BackingPackageStore>,
    new_packages: BTreeMap<ObjectID, PackageObject>,
}

impl PostExecutionPackageResolver {
    pub fn new(
        backing_store: Arc<dyn BackingPackageStore>,
        output_objects: &Option<Vec<Object>>,
    ) -> Self {
        let new_packages = output_objects
            .iter()
            .flatten()
            .filter_map(|o| {
                if o.is_package() {
                    Some((o.id(), PackageObject::new(o.clone())))
                } else {
                    None
                }
            })
            .collect();
        Self {
            backing_store,
            new_packages,
        }
    }
}

impl BackingPackageStore for PostExecutionPackageResolver {
    fn get_package_object(&self, package_id: &ObjectID) -> SuiResult<Option<PackageObject>> {
        if let Some(package) = self.new_packages.get(package_id) {
            Ok(Some(package.clone()))
        } else {
            self.backing_store.get_package_object(package_id)
        }
    }
}

pub trait ParentSync {
    /// This function is only called by older protocol versions.
    /// It creates an explicit dependency to tombstones, which is not desired.
    fn get_latest_parent_entry_ref_deprecated(&self, object_id: ObjectID) -> Option<ObjectRef>;
}

impl<S: ParentSync> ParentSync for std::sync::Arc<S> {
    fn get_latest_parent_entry_ref_deprecated(&self, object_id: ObjectID) -> Option<ObjectRef> {
        ParentSync::get_latest_parent_entry_ref_deprecated(self.as_ref(), object_id)
    }
}

impl<S: ParentSync> ParentSync for &S {
    fn get_latest_parent_entry_ref_deprecated(&self, object_id: ObjectID) -> Option<ObjectRef> {
        ParentSync::get_latest_parent_entry_ref_deprecated(*self, object_id)
    }
}

impl<S: ParentSync> ParentSync for &mut S {
    fn get_latest_parent_entry_ref_deprecated(&self, object_id: ObjectID) -> Option<ObjectRef> {
        ParentSync::get_latest_parent_entry_ref_deprecated(*self, object_id)
    }
}

impl<S: RuntimeObjectResolver> RuntimeObjectResolver for std::sync::Arc<S> {
    fn read_child_object(
        &self,
        parent: &ObjectID,
        child: &ObjectID,
        child_version_upper_bound: SequenceNumber,
    ) -> SuiResult<Option<Object>> {
        RuntimeObjectResolver::read_child_object(
            self.as_ref(),
            parent,
            child,
            child_version_upper_bound,
        )
    }
    fn get_object_received_at_version(
        &self,
        owner: &ObjectID,
        receiving_object_id: &ObjectID,
        receive_object_at_version: SequenceNumber,
        epoch_id: EpochId,
    ) -> SuiResult<Option<Object>> {
        RuntimeObjectResolver::get_object_received_at_version(
            self.as_ref(),
            owner,
            receiving_object_id,
            receive_object_at_version,
            epoch_id,
        )
    }
}

impl<S: RuntimeObjectResolver> RuntimeObjectResolver for &S {
    fn read_child_object(
        &self,
        parent: &ObjectID,
        child: &ObjectID,
        child_version_upper_bound: SequenceNumber,
    ) -> SuiResult<Option<Object>> {
        RuntimeObjectResolver::read_child_object(*self, parent, child, child_version_upper_bound)
    }
    fn get_object_received_at_version(
        &self,
        owner: &ObjectID,
        receiving_object_id: &ObjectID,
        receive_object_at_version: SequenceNumber,
        epoch_id: EpochId,
    ) -> SuiResult<Option<Object>> {
        RuntimeObjectResolver::get_object_received_at_version(
            *self,
            owner,
            receiving_object_id,
            receive_object_at_version,
            epoch_id,
        )
    }
}

impl<S: RuntimeObjectResolver> RuntimeObjectResolver for &mut S {
    fn read_child_object(
        &self,
        parent: &ObjectID,
        child: &ObjectID,
        child_version_upper_bound: SequenceNumber,
    ) -> SuiResult<Option<Object>> {
        RuntimeObjectResolver::read_child_object(*self, parent, child, child_version_upper_bound)
    }
    fn get_object_received_at_version(
        &self,
        owner: &ObjectID,
        receiving_object_id: &ObjectID,
        receive_object_at_version: SequenceNumber,
        epoch_id: EpochId,
    ) -> SuiResult<Option<Object>> {
        RuntimeObjectResolver::get_object_received_at_version(
            *self,
            owner,
            receiving_object_id,
            receive_object_at_version,
            epoch_id,
        )
    }
}

#[serde_as]
#[derive(Eq, PartialEq, Clone, Copy, PartialOrd, Ord, Hash, Serialize, Deserialize, Debug)]
pub struct ObjectKey(pub ObjectID, pub VersionNumber);

impl ObjectKey {
    pub const ZERO: ObjectKey = ObjectKey(ObjectID::ZERO, VersionNumber::MIN);

    pub fn max_for_id(id: &ObjectID) -> Self {
        Self(*id, VersionNumber::MAX)
    }

    pub fn min_for_id(id: &ObjectID) -> Self {
        Self(*id, VersionNumber::MIN)
    }
}

impl From<ObjectRef> for ObjectKey {
    fn from(object_ref: ObjectRef) -> Self {
        ObjectKey::from(&object_ref)
    }
}

impl From<&ObjectRef> for ObjectKey {
    fn from(object_ref: &ObjectRef) -> Self {
        Self(object_ref.0, object_ref.1)
    }
}

#[serde_as]
#[derive(Eq, PartialEq, Clone, Copy, PartialOrd, Ord, Hash, Serialize, Deserialize, Debug)]
pub struct ConsensusObjectKey(pub ConsensusObjectSequenceKey, pub VersionNumber);

/// FullObjectKey represents a unique object a specific version. For fastpath objects, this
/// is the same as ObjectKey. For consensus objects, this includes the start version, which
/// may change if an object is transferred out of and back into consensus.
#[serde_as]
#[derive(Eq, PartialEq, Clone, Copy, PartialOrd, Ord, Hash, Serialize, Deserialize, Debug)]
pub enum FullObjectKey {
    Fastpath(ObjectKey),
    Consensus(ConsensusObjectKey),
}

impl FullObjectKey {
    pub fn max_for_id(id: &FullObjectID) -> Self {
        match id {
            FullObjectID::Fastpath(object_id) => Self::Fastpath(ObjectKey::max_for_id(object_id)),
            FullObjectID::Consensus(consensus_object_sequence_key) => Self::Consensus(
                ConsensusObjectKey(*consensus_object_sequence_key, VersionNumber::MAX),
            ),
        }
    }

    pub fn min_for_id(id: &FullObjectID) -> Self {
        match id {
            FullObjectID::Fastpath(object_id) => Self::Fastpath(ObjectKey::min_for_id(object_id)),
            FullObjectID::Consensus(consensus_object_sequence_key) => Self::Consensus(
                ConsensusObjectKey(*consensus_object_sequence_key, VersionNumber::MIN),
            ),
        }
    }

    pub fn new(object_id: FullObjectID, version: VersionNumber) -> Self {
        match object_id {
            FullObjectID::Fastpath(object_id) => Self::Fastpath(ObjectKey(object_id, version)),
            FullObjectID::Consensus(consensus_object_sequence_key) => {
                Self::Consensus(ConsensusObjectKey(consensus_object_sequence_key, version))
            }
        }
    }

    pub fn id(&self) -> FullObjectID {
        match self {
            FullObjectKey::Fastpath(object_key) => FullObjectID::Fastpath(object_key.0),
            FullObjectKey::Consensus(consensus_object_key) => {
                FullObjectID::Consensus(consensus_object_key.0)
            }
        }
    }

    pub fn version(&self) -> VersionNumber {
        match self {
            FullObjectKey::Fastpath(object_key) => object_key.1,
            FullObjectKey::Consensus(consensus_object_key) => consensus_object_key.1,
        }
    }
}

impl From<FullObjectRef> for FullObjectKey {
    fn from(object_ref: FullObjectRef) -> Self {
        FullObjectKey::from(&object_ref)
    }
}

impl From<&FullObjectRef> for FullObjectKey {
    fn from(object_ref: &FullObjectRef) -> Self {
        FullObjectKey::new(object_ref.0, object_ref.1)
    }
}

#[derive(Clone)]
pub enum ObjectOrTombstone {
    Object(Object),
    Tombstone(ObjectRef),
}

impl ObjectOrTombstone {
    pub fn as_objref(&self) -> ObjectRef {
        match self {
            ObjectOrTombstone::Object(obj) => obj.compute_object_reference(),
            ObjectOrTombstone::Tombstone(obref) => *obref,
        }
    }
}

impl From<Object> for ObjectOrTombstone {
    fn from(object: Object) -> Self {
        ObjectOrTombstone::Object(object)
    }
}

/// Fetch the `ObjectKey`s (IDs and versions) for non-shared input objects.  Includes owned,
/// and immutable objects as well as the gas objects, but not move packages or shared objects.
pub fn transaction_non_shared_input_object_keys(
    tx: &SenderSignedData,
) -> SuiResult<Vec<ObjectKey>> {
    use crate::transaction::InputObjectKind as I;
    Ok(tx
        .intent_message()
        .value
        .input_objects()?
        .into_iter()
        .filter_map(|object| match object {
            I::MovePackage(_) | I::SharedMoveObject { .. } => None,
            I::ImmOrOwnedMoveObject(obj) => Some(obj.into()),
        })
        .collect())
}

pub fn transaction_receiving_object_keys(tx: &SenderSignedData) -> Vec<ObjectKey> {
    tx.intent_message()
        .value
        .receiving_objects()
        .into_iter()
        .map(|oref| oref.into())
        .collect()
}

impl Display for DeleteKind {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            DeleteKind::Wrap => write!(f, "Wrap"),
            DeleteKind::Normal => write!(f, "Normal"),
            DeleteKind::UnwrapThenDelete => write!(f, "UnwrapThenDelete"),
        }
    }
}

pub trait BackingStore: RuntimeObjectResolver + ObjectStore + ParentSync {}

impl<T> BackingStore for T
where
    T: RuntimeObjectResolver,
    T: ObjectStore,
    T: ParentSync,
{
}

pub fn get_transaction_input_objects(
    object_store: &dyn ObjectStore,
    effects: &TransactionEffects,
) -> Result<Vec<Object>, StorageError> {
    let input_object_keys = effects
        .modified_at_versions()
        .into_iter()
        .map(|(object_id, version)| ObjectKey(object_id, version))
        .collect::<Vec<_>>();

    let input_objects = object_store
        .multi_get_objects_by_key(&input_object_keys)
        .into_iter()
        .enumerate()
        .map(|(idx, maybe_object)| {
            maybe_object.ok_or_else(|| {
                StorageError::custom(format!(
                    "missing input object key {:?} from tx {} effects {}",
                    input_object_keys[idx],
                    effects.transaction_digest(),
                    effects.digest()
                ))
            })
        })
        .collect::<Result<Vec<_>, _>>()?;
    Ok(input_objects)
}

pub fn get_transaction_output_objects(
    object_store: &dyn ObjectStore,
    effects: &TransactionEffects,
) -> Result<Vec<Object>, StorageError> {
    let output_object_keys = effects
        .all_changed_objects()
        .into_iter()
        .map(|(object_ref, _owner, _kind)| ObjectKey::from(object_ref))
        .collect::<Vec<_>>();

    let output_objects = object_store
        .multi_get_objects_by_key(&output_object_keys)
        .into_iter()
        .enumerate()
        .map(|(idx, maybe_object)| {
            maybe_object.ok_or_else(|| {
                StorageError::custom(format!(
                    "missing output object key {:?} from tx {} effects {}",
                    output_object_keys[idx],
                    effects.transaction_digest(),
                    effects.digest()
                ))
            })
        })
        .collect::<Result<Vec<_>, _>>()?;
    Ok(output_objects)
}

impl SystemObjectVersions {
    /// Obtains pinned system object versions from effects, queries the store for the initial shared versions.
    pub fn from_effects(effects: &TransactionEffects, store: &dyn ObjectStore) -> Self {
        Self::from_map(
            effects
                .accessed_consensus_objects()
                .into_iter()
                .filter_map(|ico| {
                    let (id, version) = ico.id_and_version();
                    if !id.is_implicitly_read_system_object() || version.is_cancelled() {
                        return None;
                    }
                    let initial_shared_version = store
                        .get_object(&id)
                        .and_then(|object| object.owner().start_version())
                        // unwrap safe because if effects contain an implicitly read system object,
                        // it must exist in the store and is a shared object.
                        .unwrap();
                    Some((
                        id,
                        ConsensusObjectVersion {
                            initial_shared_version,
                            version,
                        },
                    ))
                })
                .collect(),
        )
    }

    /// Before execution, get the versions of the implicitly read system objects from the declared
    /// inputs, or else the latest from the store, and use these versions as the exact version to
    /// read during execution.
    /// This is used only in environments where there is no consensus to assign versions, e.g. simulacrum and dry-run.
    pub fn from_inputs_or_latest_in_store(
        input_objects: &InputObjects,
        store: &dyn ObjectStore,
    ) -> Self {
        Self::from_map(
            IMPLICITLY_READ_SYSTEM_OBJECTS
                .iter()
                .filter_map(|id| {
                    let object = input_objects
                        .iter_objects()
                        .find(|object| object.id() == *id)
                        .cloned()
                        .or_else(|| store.get_object(id))?;
                    let initial_shared_version = object
                        .owner()
                        .start_version()
                        .expect("implicitly read system objects must be consensus objects");
                    Some((
                        *id,
                        ConsensusObjectVersion {
                            initial_shared_version,
                            version: object.version(),
                        },
                    ))
                })
                .collect(),
        )
    }
}

// Returns a set of the ObjectKey's of objects read or written by this transaction
pub fn get_transaction_object_set(
    transaction: &TransactionData,
    effects: &TransactionEffects,
    unchanged_loaded_runtime_objects: &[ObjectKey],
) -> BTreeSet<ObjectKey> {
    // enumerate the full set of input objects in order to properly capture immutable objects that
    // may not appear in the effects.
    //
    // This excludes packages
    let input_objects = transaction
        .input_objects()
        .expect("txn was executed and must have valid input objects")
        .into_iter()
        .filter_map(|input| {
            input
                .version()
                .map(|version| ObjectKey(input.object_id(), version))
        });

    // The full set of output/written objects as well as any of their initial versions
    let modified_set = effects
        .object_changes()
        .into_iter()
        .flat_map(|change| {
            [
                change
                    .input_version
                    .map(|version| ObjectKey(change.id, version)),
                change
                    .output_version
                    .map(|version| ObjectKey(change.id, version)),
            ]
        })
        .flatten();

    // The set of unchanged consensus objects
    let unchanged_consensus =
        effects
            .unchanged_consensus_objects()
            .into_iter()
            .flat_map(|unchanged| {
                if let crate::effects::UnchangedConsensusKind::ReadOnlyRoot((version, _)) =
                    unchanged.1
                {
                    Some(ObjectKey(unchanged.0, version))
                } else {
                    None
                }
            });

    input_objects
        .chain(modified_set)
        .chain(unchanged_consensus)
        .chain(unchanged_loaded_runtime_objects.iter().copied())
        .collect()
}

// A BackingStore to pass to execution in order to track all objects loaded during execution.
//
// Today this is used to very accurately track the objects that were loaded but unchanged during
// execution.
pub struct TrackingBackingStore<'a> {
    inner: &'a dyn crate::storage::BackingStore,
    read_objects: std::cell::RefCell<ObjectSet>,
}

impl<'a> TrackingBackingStore<'a> {
    pub fn new(inner: &'a dyn crate::storage::BackingStore) -> Self {
        Self {
            inner,
            read_objects: Default::default(),
        }
    }

    pub fn into_read_objects(self) -> ObjectSet {
        self.read_objects.into_inner()
    }

    fn track_object(&self, object: &Object) {
        self.read_objects.borrow_mut().insert(object.clone());
    }
}

impl BackingPackageStore for TrackingBackingStore<'_> {
    fn get_package_object(
        &self,
        package_id: &ObjectID,
    ) -> crate::error::SuiResult<Option<PackageObject>> {
        self.inner.get_package_object(package_id).inspect(|o| {
            o.as_ref()
                .inspect(|package| self.track_object(package.object()));
        })
    }
}

impl RuntimeObjectResolver for TrackingBackingStore<'_> {
    fn read_child_object(
        &self,
        parent: &ObjectID,
        child: &ObjectID,
        child_version_upper_bound: SequenceNumber,
    ) -> crate::error::SuiResult<Option<Object>> {
        self.inner
            .read_child_object(parent, child, child_version_upper_bound)
            .inspect(|o| {
                o.as_ref().inspect(|object| self.track_object(object));
            })
    }

    fn get_object_received_at_version(
        &self,
        owner: &ObjectID,
        receiving_object_id: &ObjectID,
        receive_object_at_version: SequenceNumber,
        epoch_id: crate::committee::EpochId,
    ) -> crate::error::SuiResult<Option<Object>> {
        self.inner
            .get_object_received_at_version(
                owner,
                receiving_object_id,
                receive_object_at_version,
                epoch_id,
            )
            .inspect(|o| {
                o.as_ref().inspect(|object| self.track_object(object));
            })
    }
}

impl crate::storage::ObjectStore for TrackingBackingStore<'_> {
    fn get_object(&self, object_id: &ObjectID) -> Option<Object> {
        self.inner
            .get_object(object_id)
            .inspect(|o| self.track_object(o))
    }

    fn load_implicitly_read_system_object(
        &self,
        object_id: &ObjectID,
        version: crate::base_types::ConsensusObjectVersion,
    ) -> Option<Object> {
        self.inner
            .load_implicitly_read_system_object(object_id, version)
            .inspect(|o| self.track_object(o))
    }

    fn get_object_by_key(
        &self,
        object_id: &ObjectID,
        version: crate::base_types::VersionNumber,
    ) -> Option<Object> {
        self.inner
            .get_object_by_key(object_id, version)
            .inspect(|o| self.track_object(o))
    }
}

impl ParentSync for TrackingBackingStore<'_> {
    fn get_latest_parent_entry_ref_deprecated(
        &self,
        object_id: ObjectID,
    ) -> Option<crate::base_types::ObjectRef> {
        self.inner.get_latest_parent_entry_ref_deprecated(object_id)
    }
}