HyperlaneDB -> HyperlaneRocksDB

rust/agents/relayer/src/merkle_tree_builder.rs

@@ -3,7 +3,7 @@ use std::fmt::Display;
 use eyre::Result;
 use tracing::{debug, error, instrument};
 
-use hyperlane_base::db::{DbError, HyperlaneDB};
+use hyperlane_base::db::{DbError, HyperlaneRocksDB};
 use hyperlane_core::{
     accumulator::{incremental::IncrementalMerkle, merkle::Proof},
     ChainCommunicationError, H256,
@@ -14,7 +14,7 @@ use crate::prover::{Prover, ProverError};
 /// Struct to sync prover.
 #[derive(Debug)]
 pub struct MerkleTreeBuilder {
-    db: HyperlaneDB,
+    db: HyperlaneRocksDB,
     prover: Prover,
     incremental: IncrementalMerkle,
 }
@@ -68,7 +68,7 @@ pub enum MerkleTreeBuilderError {
 }
 
 impl MerkleTreeBuilder {
-    pub fn new(db: HyperlaneDB) -> Self {
+    pub fn new(db: HyperlaneRocksDB) -> Self {
         let prover = Prover::default();
         let incremental = IncrementalMerkle::default();
         Self {

rust/agents/relayer/src/msg/gas_payment/mod.rs

@@ -4,7 +4,7 @@ use async_trait::async_trait;
 use eyre::Result;
 use tracing::{debug, error, trace};
 
-use hyperlane_base::db::HyperlaneDB;
+use hyperlane_base::db::HyperlaneRocksDB;
 use hyperlane_core::{
     HyperlaneMessage, InterchainGasExpenditure, InterchainGasPayment, TxCostEstimate, TxOutcome,
     U256,
@@ -40,13 +40,13 @@ pub struct GasPaymentEnforcer {
     /// policy or another. If a message matches multiple policies'
     /// whitelists, then whichever is first in the list will be used.
     policies: Vec<(Box<dyn GasPaymentPolicy>, MatchingList)>,
-    db: HyperlaneDB,
+    db: HyperlaneRocksDB,
 }
 
 impl GasPaymentEnforcer {
     pub fn new(
         policy_configs: impl IntoIterator<Item = GasPaymentEnforcementConf>,
-        db: HyperlaneDB,
+        db: HyperlaneRocksDB,
     ) -> Self {
         let policies = policy_configs
             .into_iter()
@@ -136,7 +136,7 @@ impl GasPaymentEnforcer {
 mod test {
     use std::str::FromStr;
 
-    use hyperlane_base::db::{test_utils, HyperlaneDB};
+    use hyperlane_base::db::{test_utils, HyperlaneRocksDB};
     use hyperlane_core::{HyperlaneDomain, HyperlaneMessage, TxCostEstimate, H160, H256, U256};
 
     use crate::settings::{
@@ -148,7 +148,7 @@ mod test {
     #[tokio::test]
     async fn test_empty_whitelist() {
         test_utils::run_test_db(|db| async move {
-            let hyperlane_db = HyperlaneDB::new(
+            let hyperlane_db = HyperlaneRocksDB::new(
                 &HyperlaneDomain::new_test_domain("test_empty_whitelist"),
                 db,
             );
@@ -185,7 +185,7 @@ mod test {
         #[allow(unused_must_use)]
         test_utils::run_test_db(|db| async move {
             let hyperlane_db =
-                HyperlaneDB::new(&HyperlaneDomain::new_test_domain("test_no_match"), db);
+                HyperlaneRocksDB::new(&HyperlaneDomain::new_test_domain("test_no_match"), db);
             let matching_list = serde_json::from_str(r#"[{"originDomain": 234}]"#).unwrap();
             let enforcer = GasPaymentEnforcer::new(
                 // Require a payment
@@ -212,7 +212,7 @@ mod test {
     #[tokio::test]
     async fn test_non_empty_matching_list() {
         test_utils::run_test_db(|db| async move {
-            let hyperlane_db = HyperlaneDB::new(&HyperlaneDomain::new_test_domain("test_non_empty_matching_list"), db);
+            let hyperlane_db = HyperlaneRocksDB::new(&HyperlaneDomain::new_test_domain("test_non_empty_matching_list"), db);
 
             let sender_address = "0xaa000000000000000000000000000000000000aa";
             let recipient_address = "0xbb000000000000000000000000000000000000bb";

rust/agents/relayer/src/msg/processor.rs

@@ -9,7 +9,7 @@ use tokio::{
 };
 use tracing::{debug, info_span, instrument, instrument::Instrumented, Instrument};
 
-use hyperlane_base::{db::HyperlaneDB, CoreMetrics};
+use hyperlane_base::{db::HyperlaneRocksDB, CoreMetrics};
 use hyperlane_core::{HyperlaneDomain, HyperlaneMessage};
 
 use crate::{
@@ -19,7 +19,7 @@ use crate::{
 
 #[derive(Debug, new)]
 pub(crate) struct MessageProcessor {
-    db: HyperlaneDB,
+    db: HyperlaneRocksDB,
     whitelist: Arc<MatchingList>,
     blacklist: Arc<MatchingList>,
     metrics: MessageProcessorMetrics,
@@ -37,7 +37,7 @@ impl MessageProcessor {
 
     #[instrument(ret, err, skip(self), level = "info")]
     async fn main_loop(mut self) -> Result<()> {
-        // Forever, scan HyperlaneDB looking for new messages to send. When criteria are
+        // Forever, scan HyperlaneRocksDB looking for new messages to send. When criteria are
         // satisfied or the message is disqualified, push the message onto
         // self.tx_msg and then continue the scan at the next highest
         // nonce.

rust/agents/relayer/src/msg/serial_submitter.rs

@@ -11,7 +11,7 @@ use tokio::task::JoinHandle;
 use tokio::time::sleep;
 use tracing::{debug, error, info, info_span, instrument, instrument::Instrumented, Instrument};
 
-use hyperlane_base::{db::HyperlaneDB, CachingMailbox, CoreMetrics};
+use hyperlane_base::{db::HyperlaneRocksDB, CachingMailbox, CoreMetrics};
 use hyperlane_core::{HyperlaneChain, HyperlaneDomain, Mailbox, U256};
 
 use crate::msg::PendingMessage;
@@ -43,7 +43,7 @@ use super::{
 ///
 /// Finally, the SerialSubmitter ensures that message delivery is robust to
 /// destination chain reorgs prior to committing delivery status to
-/// HyperlaneDB.
+/// HyperlaneRocksDB.
 ///
 ///
 /// Objectives
@@ -86,7 +86,7 @@ pub(crate) struct SerialSubmitter {
     metadata_builder: BaseMetadataBuilder,
     /// Interface to agent rocks DB for e.g. writing delivery status upon
     /// completion.
-    db: HyperlaneDB,
+    db: HyperlaneRocksDB,
     /// Metrics for serial submitter.
     metrics: SerialSubmitterMetrics,
     /// Used to determine if messages have made sufficient gas payments.
@@ -310,11 +310,11 @@ impl SerialSubmitter {
         }
     }
 
-    /// Record in HyperlaneDB and various metrics that this process has observed
+    /// Record in HyperlaneRocksDB and various metrics that this process has observed
     /// the successful processing of a message. An `Ok(())` value returned by
     /// this function is the 'commit' point in a message's lifetime for
     /// final processing -- after this function has been seen to
-    /// `return Ok(())`, then without a wiped HyperlaneDB, we will never
+    /// `return Ok(())`, then without a wiped HyperlaneRocksDB, we will never
     /// re-attempt processing for this message again, even after the relayer
     /// restarts.
     fn record_message_process_success(&mut self, msg: &PendingMessage) -> Result<()> {

rust/agents/scraper/src/chain_scraper/sync.rs

@@ -128,7 +128,7 @@ impl Syncer {
 
         // Okay, what do we want to do here?
         // For now, let's separate out dispatched message syncing from the rest.
-        // TODO: Do smart syncing. Tricky bit is that the other cursor relies on a HyperlaneDB, which we don't have here.
+        // TODO: Do smart syncing. Tricky bit is that the other cursor relies on a HyperlaneRocksDB, which we don't have here.
         loop {
             let start_block = self.sync_cursor.current_position();
             let Ok(Some((from, to, eta))) = self.sync_cursor.next_range().await else { continue };

rust/hyperlane-base/src/contract_sync/cursor.rs

@@ -13,7 +13,7 @@ use hyperlane_core::{
     ChainResult, Indexer, MailboxIndexer, MessageSyncCursor, SyncBlockRangeCursor,
 };
 
-use crate::{contract_sync::eta_calculator::SyncerEtaCalculator, db::HyperlaneDB};
+use crate::{contract_sync::eta_calculator::SyncerEtaCalculator, db::HyperlaneRocksDB};
 
 /// Time window for the moving average used in the eta calculator in seconds.
 const ETA_TIME_WINDOW: f64 = 2. * 60.;
@@ -24,8 +24,8 @@ const ETA_TIME_WINDOW: f64 = 2. * 60.;
 pub struct MessageSyncCursorData<I> {
     /// The MailboxIndexer that this cursor is associated with.
     indexer: I,
-    /// The HyperlaneDB that this cursor is associated with.
-    db: HyperlaneDB,
+    /// The HyperlaneRocksDB that this cursor is associated with.
+    db: HyperlaneRocksDB,
     /// The size of the largest block range that should be returned by the cursor.
     chunk_size: u32,
     /// The starting block for the cursor

rust/hyperlane-base/src/contract_sync/mailbox.rs

@@ -132,7 +132,7 @@ mod test {
     use crate::{
         contract_sync::{mailbox::MOCK_CURSOR, schema::MailboxContractSyncDB, IndexSettings},
         db::test_utils,
-        db::HyperlaneDB,
+        db::HyperlaneRocksDB,
         ContractSync, ContractSyncMetrics, CoreMetrics,
     };
 
@@ -278,7 +278,7 @@ mod test {
                 });
             }
 
-            let hyperlane_db = HyperlaneDB::new(
+            let hyperlane_db = HyperlaneRocksDB::new(
                 &HyperlaneDomain::new_test_domain("handles_missing_rpc_messages"),
                 db,
             );

rust/hyperlane-base/src/contract_sync/metrics.rs

@@ -12,7 +12,7 @@ pub struct ContractSyncMetrics {
     /// - `chain`: Chain the indexer is collecting data from.
     pub indexed_height: IntGaugeVec,
 
-    /// Events stored into HyperlaneDB (label values differentiate checkpoints vs.
+    /// Events stored into HyperlaneRocksDB (label values differentiate checkpoints vs.
     /// messages)
     ///
     /// Labels:

rust/hyperlane-base/src/contract_sync/mod.rs

@@ -6,7 +6,7 @@ pub use interchain_gas::*;
 pub use mailbox::*;
 pub use metrics::ContractSyncMetrics;
 
-use crate::{chains::IndexSettings, db::HyperlaneDB};
+use crate::{chains::IndexSettings, db::HyperlaneRocksDB};
 
 mod cursor;
 mod eta_calculator;
@@ -24,7 +24,7 @@ mod schema;
 #[derive(Debug, new, Clone)]
 pub(crate) struct ContractSync<I> {
     domain: HyperlaneDomain,
-    db: HyperlaneDB,
+    db: HyperlaneRocksDB,
     indexer: I,
     index_settings: IndexSettings,
     metrics: ContractSyncMetrics,

rust/hyperlane-base/src/contract_sync/schema.rs

@@ -1,6 +1,6 @@
 use eyre::Result;
 
-use crate::db::{DbError, HyperlaneDB};
+use crate::db::{DbError, HyperlaneRocksDB};
 
 /// The start block number of the latest "valid" message block range.
 /// This is an interval of block indexes where > 0 messages were indexed,
@@ -10,12 +10,13 @@ use crate::db::{DbError, HyperlaneDB};
 static LATEST_VALID_MESSAGE_RANGE_START_BLOCK: &str = "latest_valid_message_range_start_block";
 static LATEST_INDEXED_GAS_PAYMENT_BLOCK: &str = "latest_indexed_gas_payment_block";
 
+// TODO: Can all of these be deleted?
 pub(crate) trait MailboxContractSyncDB {
     fn store_latest_valid_message_range_start_block(&self, block_num: u32) -> Result<(), DbError>;
     fn retrieve_latest_valid_message_range_start_block(&self) -> Option<u32>;
 }
 
-impl MailboxContractSyncDB for HyperlaneDB {
+impl MailboxContractSyncDB for HyperlaneRocksDB {
     fn store_latest_valid_message_range_start_block(&self, block_num: u32) -> Result<(), DbError> {
         self.store_encodable("", LATEST_VALID_MESSAGE_RANGE_START_BLOCK, &block_num)
     }
@@ -31,7 +32,7 @@ pub(crate) trait InterchainGasPaymasterContractSyncDB {
     fn retrieve_latest_indexed_gas_payment_block(&self) -> Option<u32>;
 }
 
-impl InterchainGasPaymasterContractSyncDB for HyperlaneDB {
+impl InterchainGasPaymasterContractSyncDB for HyperlaneRocksDB {
     fn store_latest_indexed_gas_payment_block(&self, latest_block: u32) -> Result<(), DbError> {
         self.store_encodable("", LATEST_INDEXED_GAS_PAYMENT_BLOCK, &latest_block)
     }

rust/hyperlane-base/src/db/mod.rs

@@ -1,106 +1,4 @@
-use std::path::PathBuf;
-use std::{io, path::Path, sync::Arc};
-
-use hyperlane_core::HyperlaneProtocolError;
-use rocksdb::{Options, DB as Rocks};
-use tracing::info;
-
-pub use hyperlane_db::*;
-pub use typed_db::*;
-
-/// Shared functionality surrounding use of rocksdb
-pub mod iterator;
+pub use rocks::*;
 
 /// DB operations tied to specific Mailbox
-mod hyperlane_db;
-/// Type-specific db operations
-mod typed_db;
-
-/// Internal-use storage types.
-mod storage_types;
-
-/// Database test utilities.
-#[cfg(any(test, feature = "test-utils"))]
-pub mod test_utils;
-
-#[derive(Debug, Clone)]
-/// A KV Store
-pub struct DB(Arc<Rocks>);
-
-impl From<Rocks> for DB {
-    fn from(rocks: Rocks) -> Self {
-        Self(Arc::new(rocks))
-    }
-}
-
-/// DB Error type
-#[derive(thiserror::Error, Debug)]
-pub enum DbError {
-    /// Rocks DB Error
-    #[error("{0}")]
-    RockError(#[from] rocksdb::Error),
-    #[error("Failed to open {path}, canonicalized as {canonicalized}: {source}")]
-    /// Error opening the database
-    OpeningError {
-        /// Rocksdb error during opening
-        #[source]
-        source: rocksdb::Error,
-        /// Raw database path provided
-        path: PathBuf,
-        /// Parsed path used
-        canonicalized: PathBuf,
-    },
-    /// Could not parse the provided database path string
-    #[error("Invalid database path supplied {1:?}; {0}")]
-    InvalidDbPath(#[source] io::Error, String),
-    /// Hyperlane Error
-    #[error("{0}")]
-    HyperlaneError(#[from] HyperlaneProtocolError),
-}
-
-type Result<T> = std::result::Result<T, DbError>;
-
-impl DB {
-    /// Opens db at `db_path` and creates if missing
-    #[tracing::instrument(err)]
-    pub fn from_path(db_path: &Path) -> Result<DB> {
-        let path = {
-            let mut path = db_path
-                .parent()
-                .unwrap_or(Path::new("."))
-                .canonicalize()
-                .map_err(|e| DbError::InvalidDbPath(e, db_path.to_string_lossy().into()))?;
-            if let Some(file_name) = db_path.file_name() {
-                path.push(file_name);
-            }
-            path
-        };
-
-        if path.is_dir() {
-            info!(path=%path.to_string_lossy(), "Opening existing db")
-        } else {
-            info!(path=%path.to_string_lossy(), "Creating db")
-        }
-
-        let mut opts = Options::default();
-        opts.create_if_missing(true);
-
-        Rocks::open(&opts, &path)
-            .map_err(|e| DbError::OpeningError {
-                source: e,
-                path: db_path.into(),
-                canonicalized: path,
-            })
-            .map(Into::into)
-    }
-
-    /// Store a value in the DB
-    pub fn store(&self, key: &[u8], value: &[u8]) -> Result<()> {
-        Ok(self.0.put(key, value)?)
-    }
-
-    /// Retrieve a value from the DB
-    pub fn retrieve(&self, key: &[u8]) -> Result<Option<Vec<u8>>> {
-        Ok(self.0.get(key)?)
-    }
-}
+mod rocks;