rest: properly expose the lowest available checkpoint watermark

crates/simulacrum/src/lib.rs

@@ -46,7 +46,7 @@ use self::epoch_state::EpochState;
 pub use self::store::in_mem_store::InMemoryStore;
 use self::store::in_mem_store::KeyStore;
 pub use self::store::SimulatorStore;
-use sui_types::messages_checkpoint::CheckpointContents;
+use sui_types::messages_checkpoint::{CheckpointContents, CheckpointSequenceNumber};
 use sui_types::mock_checkpoint_builder::{MockCheckpointBuilder, ValidatorKeypairProvider};
 use sui_types::{
     gas_coin::GasCoin,
@@ -559,6 +559,12 @@ impl<T: Send + Sync, V: store::SimulatorStore + Send + Sync> RestStateReader for
         todo!()
     }
 
+    fn get_lowest_available_checkpoint_objects(
+        &self,
+    ) -> sui_types::storage::error::Result<CheckpointSequenceNumber> {
+        Ok(0)
+    }
+
     fn get_chain_identifier(
         &self,
     ) -> sui_types::storage::error::Result<sui_types::digests::ChainIdentifier> {

crates/sui-core/src/execution_cache.rs

@@ -454,6 +454,9 @@ pub trait ObjectCacheRead: Send + Sync {
             _ => Ok(false),
         }
     }
+
+    /// Return the watermark for the highest checkpoint for which we've pruned objects.
+    fn get_highest_pruned_checkpoint(&self) -> SuiResult<CheckpointSequenceNumber>;
 }
 
 pub trait TransactionCacheRead: Send + Sync {

crates/sui-core/src/execution_cache/passthrough_cache.rs

@@ -182,6 +182,10 @@ impl ObjectCacheRead for PassthroughCache {
     ) -> SuiResult<Option<(SequenceNumber, MarkerValue)>> {
         self.store.get_latest_marker(object_id, epoch_id)
     }
+
+    fn get_highest_pruned_checkpoint(&self) -> SuiResult<CheckpointSequenceNumber> {
+        self.store.perpetual_tables.get_highest_pruned_checkpoint()
+    }
 }
 
 impl TransactionCacheRead for PassthroughCache {

crates/sui-core/src/execution_cache/proxy_cache.rs

@@ -193,6 +193,10 @@ impl ObjectCacheRead for ProxyCache {
     ) -> SuiResult<Option<(SequenceNumber, MarkerValue)>> {
         delegate_method!(self.get_latest_marker(object_id, epoch_id))
     }
+
+    fn get_highest_pruned_checkpoint(&self) -> SuiResult<CheckpointSequenceNumber> {
+        delegate_method!(self.get_highest_pruned_checkpoint())
+    }
 }
 
 impl TransactionCacheRead for ProxyCache {

crates/sui-core/src/execution_cache/writeback_cache.rs

@@ -1605,6 +1605,10 @@ impl ObjectCacheRead for WritebackCache {
         )?;
         Ok(())
     }
+
+    fn get_highest_pruned_checkpoint(&self) -> SuiResult<CheckpointSequenceNumber> {
+        self.store.perpetual_tables.get_highest_pruned_checkpoint()
+    }
 }
 
 impl TransactionCacheRead for WritebackCache {

crates/sui-core/src/storage.rs

@@ -480,6 +480,16 @@ impl RestStateReader for RestReadStore {
             .map_err(StorageError::custom)
     }
 
+    fn get_lowest_available_checkpoint_objects(
+        &self,
+    ) -> sui_types::storage::error::Result<CheckpointSequenceNumber> {
+        self.state
+            .get_object_cache_reader()
+            .get_highest_pruned_checkpoint()
+            .map(|seq| seq + 1)
+            .map_err(StorageError::custom)
+    }
+
     fn get_chain_identifier(
         &self,
     ) -> sui_types::storage::error::Result<sui_types::digests::ChainIdentifier> {

crates/sui-rest-api/src/info.rs

@@ -14,11 +14,16 @@ pub async fn node_info(
     State(state): State<RestService>,
 ) -> Result<ResponseContent<NodeInfo>> {
     let latest_checkpoint = state.reader.inner().get_latest_checkpoint()?;
-    let oldest_checkpoint = state.reader.inner().get_lowest_available_checkpoint()?;
+    let lowest_available_checkpoint = state.reader.inner().get_lowest_available_checkpoint()?;
+    let lowest_available_checkpoint_objects = state
+        .reader
+        .inner()
+        .get_lowest_available_checkpoint_objects()?;
 
     let response = NodeInfo {
         checkpoint_height: latest_checkpoint.sequence_number,
-        oldest_checkpoint_height: oldest_checkpoint,
+        lowest_available_checkpoint,
+        lowest_available_checkpoint_objects,
         timestamp_ms: latest_checkpoint.timestamp_ms,
         epoch: latest_checkpoint.epoch(),
         chain_id: state.chain_id(),
@@ -40,7 +45,8 @@ pub struct NodeInfo {
     pub epoch: u64,
     pub checkpoint_height: u64,
     pub timestamp_ms: u64,
-    pub oldest_checkpoint_height: u64,
+    pub lowest_available_checkpoint: u64,
+    pub lowest_available_checkpoint_objects: u64,
     pub software_version: Cow<'static, str>,
     //TODO include current protocol version
 }

crates/sui-rest-api/src/response.rs

@@ -12,7 +12,8 @@ use crate::{
     content_type::ContentType,
     types::{
         X_SUI_CHAIN, X_SUI_CHAIN_ID, X_SUI_CHECKPOINT_HEIGHT, X_SUI_EPOCH,
-        X_SUI_OLDEST_CHECKPOINT_HEIGHT, X_SUI_TIMESTAMP_MS,
+        X_SUI_LOWEST_AVAILABLE_CHECKPOINT, X_SUI_LOWEST_AVAILABLE_CHECKPOINT_OBJECTS,
+        X_SUI_TIMESTAMP_MS,
     },
     RestService, APPLICATION_BCS, TEXT_PLAIN_UTF_8,
 };
@@ -129,12 +130,18 @@ pub async fn append_info_headers(
     response: Response,
 ) -> impl IntoResponse {
     let latest_checkpoint = state.reader.inner().get_latest_checkpoint().unwrap();
-    let oldest_checkpoint = state
+    let lowest_available_checkpoint = state
         .reader
         .inner()
         .get_lowest_available_checkpoint()
         .unwrap();
 
+    let lowest_available_checkpoint_objects = state
+        .reader
+        .inner()
+        .get_lowest_available_checkpoint_objects()
+        .unwrap();
+
     let mut headers = HeaderMap::new();
 
     headers.insert(
@@ -166,8 +173,16 @@ pub async fn append_info_headers(
             .unwrap(),
     );
     headers.insert(
-        X_SUI_OLDEST_CHECKPOINT_HEIGHT,
-        oldest_checkpoint.to_string().try_into().unwrap(),
+        X_SUI_LOWEST_AVAILABLE_CHECKPOINT,
+        lowest_available_checkpoint.to_string().try_into().unwrap(),
+    );
+
+    headers.insert(
+        X_SUI_LOWEST_AVAILABLE_CHECKPOINT_OBJECTS,
+        lowest_available_checkpoint_objects
+            .to_string()
+            .try_into()
+            .unwrap(),
     );
 
     (headers, response)

crates/sui-rest-api/src/types.rs

@@ -10,8 +10,21 @@ pub const X_SUI_CHAIN: &str = "x-sui-chain";
 /// Current checkpoint height
 pub const X_SUI_CHECKPOINT_HEIGHT: &str = "x-sui-checkpoint-height";
 
-/// Oldest non-pruned checkpoint height
-pub const X_SUI_OLDEST_CHECKPOINT_HEIGHT: &str = "x-sui-oldest-checkpoint-height";
+/// Lowest available checkpoint for which transaction and checkpoint data can be requested.
+///
+/// Specifically this is the lowest checkpoint for which the following data can be requested:
+///  - checkpoints
+///  - transactions
+///  - effects
+///  - events
+pub const X_SUI_LOWEST_AVAILABLE_CHECKPOINT: &str = "x-sui-lowest-available-checkpoint";
+
+/// Lowest available checkpoint for which object data can be requested.
+///
+/// Specifically this is the lowest checkpoint for which input/output object data will be
+/// available.
+pub const X_SUI_LOWEST_AVAILABLE_CHECKPOINT_OBJECTS: &str =
+    "x-sui-lowest-available-checkpoint-objects";
 
 /// Current epoch of the chain
 pub const X_SUI_EPOCH: &str = "x-sui-epoch";

crates/sui-transactional-test-runner/src/simulator_persisted_store.rs

@@ -713,6 +713,12 @@ impl RestStateReader for PersistedStoreInnerReadOnlyWrapper {
         todo!()
     }
 
+    fn get_lowest_available_checkpoint_objects(
+        &self,
+    ) -> sui_types::storage::error::Result<CheckpointSequenceNumber> {
+        Ok(0)
+    }
+
     fn get_chain_identifier(
         &self,
     ) -> sui_types::storage::error::Result<sui_types::digests::ChainIdentifier> {

crates/sui-types/src/storage/read_store.rs

@@ -56,7 +56,15 @@ pub trait ReadStore: ObjectStore {
     /// are guaranteed to be present in the store
     fn get_highest_synced_checkpoint(&self) -> Result<VerifiedCheckpoint>;
 
-    /// The lowest available checkpoint that hasn't yet been pruned.
+    /// Lowest available checkpoint for which transaction and checkpoint data can be requested.
+    ///
+    /// Specifically this is the lowest checkpoint for which the following data can be requested:
+    ///  - checkpoints
+    ///  - transactions
+    ///  - effects
+    ///  - events
+    ///
+    /// For object availability see `get_lowest_available_checkpoint_objects`.
     fn get_lowest_available_checkpoint(&self) -> Result<CheckpointSequenceNumber>;
 
     fn get_checkpoint_by_digest(
@@ -639,5 +647,11 @@ pub trait RestStateReader: ObjectStore + ReadStore + Send + Sync {
         digest: &TransactionDigest,
     ) -> Result<Option<CheckpointSequenceNumber>>;
 
+    /// Lowest available checkpoint for which object data can be requested.
+    ///
+    /// Specifically this is the lowest checkpoint for which input/output object data will be
+    /// available.
+    fn get_lowest_available_checkpoint_objects(&self) -> Result<CheckpointSequenceNumber>;
+
     fn get_chain_identifier(&self) -> Result<ChainIdentifier>;
 }