Revert AuthorityStore deprecated functions to fix `AuthorityStore::…

…multi_get_transaction_checkpoint` (#4164) * Revert "refactor(iota-core): Remove deprecated `AuthorityPerpetualTables`/`AuthorityStore` related code (#3829)" This reverts commit d891762. * fix(iota-core): cleanup/rename stuff still in use but marked as deprecated after previous revert * Fmt * Add get_transaction_checkpoint back * feat(iota-json-rpc-tests): add get_transaction_block_timestamp test Test by @kodemartin. --------- Co-authored-by: Vlad Semenov <[email protected]> Co-authored-by: Vlad Semenov <[email protected]>
iotaledger · Nov 26, 2024 · 29eda32 · 29eda32
1 parent d081fc0
commit 29eda32
Show file tree

Hide file tree

Showing 17 changed files with 325 additions and 56 deletions.
diff --git a/crates/iota-core/src/authority.rs b/crates/iota-core/src/authority.rs
@@ -143,8 +143,9 @@ use crate::{
     consensus_adapter::ConsensusAdapter,
     epoch::committee_store::CommitteeStore,
     execution_cache::{
-        ExecutionCacheCommit, ExecutionCacheReconfigAPI, ExecutionCacheTraitPointers,
-        ExecutionCacheWrite, ObjectCacheRead, StateSyncAPI, TransactionCacheRead,
+        CheckpointCache, ExecutionCacheCommit, ExecutionCacheReconfigAPI,
+        ExecutionCacheTraitPointers, ExecutionCacheWrite, ObjectCacheRead, StateSyncAPI,
+        TransactionCacheRead,
     },
     execution_driver::execution_process,
     metrics::{LatencyObserver, RateTracker},
@@ -2735,6 +2736,10 @@ impl AuthorityState {
         &self.execution_cache_trait_pointers.accumulator_store
     }
 
+    pub fn get_checkpoint_cache(&self) -> &Arc<dyn CheckpointCache> {
+        &self.execution_cache_trait_pointers.checkpoint_cache
+    }
+
     pub fn get_state_sync_store(&self) -> &Arc<dyn StateSyncAPI> {
         &self.execution_cache_trait_pointers.state_sync_store
     }
@@ -3141,15 +3146,6 @@ impl AuthorityState {
             .get_iota_system_state_object_unsafe()
     }
 
-    #[instrument(level = "trace", skip_all)]
-    fn get_transaction_checkpoint_sequence(
-        &self,
-        digest: &TransactionDigest,
-        epoch_store: &AuthorityPerEpochStore,
-    ) -> IotaResult<Option<CheckpointSequenceNumber>> {
-        epoch_store.get_transaction_checkpoint(digest)
-    }
-
     #[instrument(level = "trace", skip_all)]
     pub fn get_checkpoint_by_sequence_number(
         &self,
@@ -3166,7 +3162,7 @@ impl AuthorityState {
         digest: &TransactionDigest,
         epoch_store: &AuthorityPerEpochStore,
     ) -> IotaResult<Option<VerifiedCheckpoint>> {
-        let checkpoint = self.get_transaction_checkpoint_sequence(digest, epoch_store)?;
+        let checkpoint = epoch_store.get_transaction_checkpoint(digest)?;
         let Some(checkpoint) = checkpoint else {
             return Ok(None);
         };
@@ -4981,6 +4977,15 @@ impl TransactionKeyValueStoreTrait for AuthorityState {
         Ok((summaries, contents, summaries_by_digest, contents_by_digest))
     }
 
+    async fn get_transaction_perpetual_checkpoint(
+        &self,
+        digest: TransactionDigest,
+    ) -> IotaResult<Option<CheckpointSequenceNumber>> {
+        self.get_checkpoint_cache()
+            .get_transaction_perpetual_checkpoint(&digest)
+            .map(|res| res.map(|(_epoch, checkpoint)| checkpoint))
+    }
+
     async fn get_object(
         &self,
         object_id: ObjectID,
@@ -4991,14 +4996,18 @@ impl TransactionKeyValueStoreTrait for AuthorityState {
             .map_err(Into::into)
     }
 
-    async fn multi_get_transaction_checkpoint(
+    async fn multi_get_transactions_perpetual_checkpoints(
         &self,
         digests: &[TransactionDigest],
     ) -> IotaResult<Vec<Option<CheckpointSequenceNumber>>> {
-        Ok(self
-            .epoch_store
-            .load()
-            .multi_get_transaction_checkpoint(digests)?)
+        let res = self
+            .get_checkpoint_cache()
+            .multi_get_transactions_perpetual_checkpoints(digests)?;
+
+        Ok(res
+            .into_iter()
+            .map(|maybe| maybe.map(|(_epoch, checkpoint)| checkpoint))
+            .collect())
     }
 }
 

diff --git a/crates/iota-core/src/authority/authority_store.rs b/crates/iota-core/src/authority/authority_store.rs
@@ -541,6 +541,48 @@ impl AuthorityStore {
         Ok(result)
     }
 
+    // Implementation of the corresponding method of `CheckpointCache` trait.
+    pub(crate) fn insert_finalized_transactions_perpetual_checkpoints(
+        &self,
+        digests: &[TransactionDigest],
+        epoch: EpochId,
+        sequence: CheckpointSequenceNumber,
+    ) -> IotaResult {
+        let mut batch = self
+            .perpetual_tables
+            .executed_transactions_to_checkpoint
+            .batch();
+        batch.insert_batch(
+            &self.perpetual_tables.executed_transactions_to_checkpoint,
+            digests.iter().map(|d| (*d, (epoch, sequence))),
+        )?;
+        batch.write()?;
+        trace!("Transactions {digests:?} finalized at checkpoint {sequence} epoch {epoch}");
+        Ok(())
+    }
+
+    // Implementation of the corresponding method of `CheckpointCache` trait.
+    pub(crate) fn get_transaction_perpetual_checkpoint(
+        &self,
+        digest: &TransactionDigest,
+    ) -> IotaResult<Option<(EpochId, CheckpointSequenceNumber)>> {
+        Ok(self
+            .perpetual_tables
+            .executed_transactions_to_checkpoint
+            .get(digest)?)
+    }
+
+    // Implementation of the corresponding method of `CheckpointCache` trait.
+    pub(crate) fn multi_get_transactions_perpetual_checkpoints(
+        &self,
+        digests: &[TransactionDigest],
+    ) -> IotaResult<Vec<Option<(EpochId, CheckpointSequenceNumber)>>> {
+        Ok(self
+            .perpetual_tables
+            .executed_transactions_to_checkpoint
+            .multi_get(digests)?)
+    }
+
     /// Returns true if there are no objects in the database
     pub fn database_is_empty(&self) -> IotaResult<bool> {
         self.perpetual_tables.database_is_empty()

diff --git a/crates/iota-core/src/authority/authority_store_pruner.rs b/crates/iota-core/src/authority/authority_store_pruner.rs
@@ -269,6 +269,10 @@ impl AuthorityStorePruner {
 
         perpetual_batch.delete_batch(&perpetual_db.transactions, transactions.iter())?;
         perpetual_batch.delete_batch(&perpetual_db.executed_effects, transactions.iter())?;
+        perpetual_batch.delete_batch(
+            &perpetual_db.executed_transactions_to_checkpoint,
+            transactions,
+        )?;
 
         let mut effect_digests = vec![];
         for effects in effects_to_prune {

diff --git a/crates/iota-core/src/authority/authority_store_tables.rs b/crates/iota-core/src/authority/authority_store_tables.rs
@@ -102,6 +102,13 @@ pub struct AuthorityPerpetualTables {
     #[default_options_override_fn = "events_table_default_config"]
     pub(crate) events: DBMap<(TransactionEventsDigest, usize), Event>,
 
+    /// Epoch and checkpoint of transactions finalized by checkpoint
+    /// executor. Currently, mainly used to implement JSON RPC `ReadApi`.
+    /// Note, there is a table with the same name in
+    /// `AuthorityEpochTables`/`AuthorityPerEpochStore`.
+    pub(crate) executed_transactions_to_checkpoint:
+        DBMap<TransactionDigest, (EpochId, CheckpointSequenceNumber)>,
+
     // Finalized root state accumulator for epoch, to be included in CheckpointSummary
     // of last checkpoint of epoch. These values should only ever be written once
     // and never changed
@@ -349,6 +356,13 @@ impl AuthorityPerpetualTables {
         Ok(self.effects.get(&effect_digest)?)
     }
 
+    pub fn get_checkpoint_sequence_number(
+        &self,
+        digest: &TransactionDigest,
+    ) -> IotaResult<Option<(EpochId, CheckpointSequenceNumber)>> {
+        Ok(self.executed_transactions_to_checkpoint.get(digest)?)
+    }
+
     pub fn get_newer_object_keys(
         &self,
         object: &(ObjectID, SequenceNumber),
@@ -418,6 +432,7 @@ impl AuthorityPerpetualTables {
         self.live_owned_object_markers.unsafe_clear()?;
         self.executed_effects.unsafe_clear()?;
         self.events.unsafe_clear()?;
+        self.executed_transactions_to_checkpoint.unsafe_clear()?;
         self.root_state_hash_by_epoch.unsafe_clear()?;
         self.epoch_start_configuration.unsafe_clear()?;
         self.pruned_checkpoint.unsafe_clear()?;

diff --git a/crates/iota-core/src/checkpoints/checkpoint_executor/mod.rs b/crates/iota-core/src/checkpoints/checkpoint_executor/mod.rs
@@ -1304,6 +1304,15 @@ async fn finalize_checkpoint(
     debug!("finalizing checkpoint");
     epoch_store.insert_finalized_transactions(tx_digests, checkpoint.sequence_number)?;
 
+    // TODO remove once we no longer need to support this table for read RPC
+    state
+        .get_checkpoint_cache()
+        .insert_finalized_transactions_perpetual_checkpoints(
+            tx_digests,
+            epoch_store.epoch(),
+            checkpoint.sequence_number,
+        )?;
+
     let checkpoint_acc =
         accumulator.accumulate_checkpoint(effects, checkpoint.sequence_number, epoch_store)?;
 

diff --git a/crates/iota-core/src/execution_cache.rs b/crates/iota-core/src/execution_cache.rs
@@ -63,6 +63,7 @@ pub struct ExecutionCacheTraitPointers {
     pub object_store: Arc<dyn ObjectStore + Send + Sync>,
     pub reconfig_api: Arc<dyn ExecutionCacheReconfigAPI>,
     pub accumulator_store: Arc<dyn AccumulatorStore>,
+    pub checkpoint_cache: Arc<dyn CheckpointCache>,
     pub state_sync_store: Arc<dyn StateSyncAPI>,
     pub cache_commit: Arc<dyn ExecutionCacheCommit>,
     pub testing_api: Arc<dyn TestingAPI>,
@@ -79,6 +80,7 @@ impl ExecutionCacheTraitPointers {
             + ObjectStore
             + ExecutionCacheReconfigAPI
             + AccumulatorStore
+            + CheckpointCache
             + StateSyncAPI
             + ExecutionCacheCommit
             + TestingAPI
@@ -93,6 +95,7 @@ impl ExecutionCacheTraitPointers {
             object_store: cache.clone(),
             reconfig_api: cache.clone(),
             accumulator_store: cache.clone(),
+            checkpoint_cache: cache.clone(),
             state_sync_store: cache.clone(),
             cache_commit: cache.clone(),
             testing_api: cache.clone(),
@@ -655,6 +658,32 @@ pub trait ExecutionCacheWrite: Send + Sync {
     ) -> BoxFuture<'a, IotaResult>;
 }
 
+pub trait CheckpointCache: Send + Sync {
+    // TODO: In addition to the methods below, this will eventually
+    // include access to the CheckpointStore.
+
+    // Note, the methods below were deemed deprecated before.
+    // Currently, they are only used to implement `get_transaction_block`
+    // for JSON RPC `ReadApi`.
+
+    fn get_transaction_perpetual_checkpoint(
+        &self,
+        digest: &TransactionDigest,
+    ) -> IotaResult<Option<(EpochId, CheckpointSequenceNumber)>>;
+
+    fn multi_get_transactions_perpetual_checkpoints(
+        &self,
+        digests: &[TransactionDigest],
+    ) -> IotaResult<Vec<Option<(EpochId, CheckpointSequenceNumber)>>>;
+
+    fn insert_finalized_transactions_perpetual_checkpoints(
+        &self,
+        digests: &[TransactionDigest],
+        epoch: EpochId,
+        sequence: CheckpointSequenceNumber,
+    ) -> IotaResult;
+}
+
 pub trait ExecutionCacheReconfigAPI: Send + Sync {
     fn insert_genesis_object(&self, object: Object) -> IotaResult;
     fn bulk_insert_genesis_objects(&self, objects: &[Object]) -> IotaResult;
@@ -800,6 +829,33 @@ macro_rules! implement_storage_traits {
 // store.
 macro_rules! implement_passthrough_traits {
     ($implementor: ident) => {
+        impl CheckpointCache for $implementor {
+            fn get_transaction_perpetual_checkpoint(
+                &self,
+                digest: &TransactionDigest,
+            ) -> IotaResult<Option<(EpochId, CheckpointSequenceNumber)>> {
+                self.store.get_transaction_perpetual_checkpoint(digest)
+            }
+
+            fn multi_get_transactions_perpetual_checkpoints(
+                &self,
+                digests: &[TransactionDigest],
+            ) -> IotaResult<Vec<Option<(EpochId, CheckpointSequenceNumber)>>> {
+                self.store
+                    .multi_get_transactions_perpetual_checkpoints(digests)
+            }
+
+            fn insert_finalized_transactions_perpetual_checkpoints(
+                &self,
+                digests: &[TransactionDigest],
+                epoch: EpochId,
+                sequence: CheckpointSequenceNumber,
+            ) -> IotaResult {
+                self.store
+                    .insert_finalized_transactions_perpetual_checkpoints(digests, epoch, sequence)
+            }
+        }
+
         impl ExecutionCacheReconfigAPI for $implementor {
             fn insert_genesis_object(&self, object: Object) -> IotaResult {
                 self.store.insert_genesis_object(object)
@@ -900,6 +956,7 @@ pub trait ExecutionCacheAPI:
     + ExecutionCacheWrite
     + ExecutionCacheCommit
     + ExecutionCacheReconfigAPI
+    + CheckpointCache
     + StateSyncAPI
 {
 }
diff --git a/crates/iota-core/src/execution_cache/passthrough_cache.rs b/crates/iota-core/src/execution_cache/passthrough_cache.rs
@@ -27,8 +27,9 @@ use tracing::instrument;
 use typed_store::Map;
 
 use super::{
-    ExecutionCacheCommit, ExecutionCacheMetrics, ExecutionCacheReconfigAPI, ExecutionCacheWrite,
-    ObjectCacheRead, StateSyncAPI, TestingAPI, TransactionCacheRead, implement_passthrough_traits,
+    CheckpointCache, ExecutionCacheCommit, ExecutionCacheMetrics, ExecutionCacheReconfigAPI,
+    ExecutionCacheWrite, ObjectCacheRead, StateSyncAPI, TestingAPI, TransactionCacheRead,
+    implement_passthrough_traits,
 };
 use crate::{
     authority::{

diff --git a/crates/iota-core/src/execution_cache/proxy_cache.rs b/crates/iota-core/src/execution_cache/proxy_cache.rs
@@ -21,7 +21,7 @@ use iota_types::{
 use parking_lot::RwLock;
 
 use super::{
-    ExecutionCacheCommit, ExecutionCacheConfigType, ExecutionCacheMetrics,
+    CheckpointCache, ExecutionCacheCommit, ExecutionCacheConfigType, ExecutionCacheMetrics,
     ExecutionCacheReconfigAPI, ExecutionCacheWrite, ObjectCacheRead, PassthroughCache,
     StateSyncAPI, TestingAPI, TransactionCacheRead, WritebackCache,
 };
@@ -317,6 +317,33 @@ impl ExecutionCacheCommit for ProxyCache {
     }
 }
 
+impl CheckpointCache for ProxyCache {
+    fn get_transaction_perpetual_checkpoint(
+        &self,
+        digest: &TransactionDigest,
+    ) -> IotaResult<Option<(EpochId, CheckpointSequenceNumber)>> {
+        delegate_method!(self.get_transaction_perpetual_checkpoint(digest))
+    }
+
+    fn multi_get_transactions_perpetual_checkpoints(
+        &self,
+        digests: &[TransactionDigest],
+    ) -> IotaResult<Vec<Option<(EpochId, CheckpointSequenceNumber)>>> {
+        delegate_method!(self.multi_get_transactions_perpetual_checkpoints(digests))
+    }
+
+    fn insert_finalized_transactions_perpetual_checkpoints(
+        &self,
+        digests: &[TransactionDigest],
+        epoch: EpochId,
+        sequence: CheckpointSequenceNumber,
+    ) -> IotaResult {
+        delegate_method!(
+            self.insert_finalized_transactions_perpetual_checkpoints(digests, epoch, sequence)
+        )
+    }
+}
+
 impl ExecutionCacheReconfigAPI for ProxyCache {
     fn insert_genesis_object(&self, object: Object) -> IotaResult {
         delegate_method!(self.insert_genesis_object(object))

diff --git a/crates/iota-core/src/execution_cache/writeback_cache.rs b/crates/iota-core/src/execution_cache/writeback_cache.rs
@@ -78,9 +78,10 @@ use tap::TapOptional;
 use tracing::{debug, info, instrument, trace, warn};
 
 use super::{
-    ExecutionCacheAPI, ExecutionCacheCommit, ExecutionCacheMetrics, ExecutionCacheReconfigAPI,
-    ExecutionCacheWrite, ObjectCacheRead, StateSyncAPI, TestingAPI, TransactionCacheRead,
-    cache_types::CachedVersionMap, implement_passthrough_traits, object_locks::ObjectLocks,
+    CheckpointCache, ExecutionCacheAPI, ExecutionCacheCommit, ExecutionCacheMetrics,
+    ExecutionCacheReconfigAPI, ExecutionCacheWrite, ObjectCacheRead, StateSyncAPI, TestingAPI,
+    TransactionCacheRead, cache_types::CachedVersionMap, implement_passthrough_traits,
+    object_locks::ObjectLocks,
 };
 use crate::{
     authority::{