Open LMDB database with WRITEMAP when not on MacOS

Cargo.toml

@@ -7,6 +7,7 @@ edition = "2021"
 autotests = false
 
 [dependencies]
+anyhow = "1.0.56"
 bitcoin = "0.27.1"
 bitcoincore-rpc = "0.14.0"
 chrono = "0.4.19"

src/bytes.rs

@@ -32,7 +32,7 @@ impl FromStr for Bytes {
       "tib" => TI,
       "pib" => PI,
       "eib" => EI,
-      _ => return Err("invalid suffix".into()),
+      _ => return Err(anyhow!("invalid suffix")),
     };
 
     Ok(Bytes((value * multiple as f64) as usize))

src/index.rs

@@ -16,17 +16,18 @@ impl Index {
       options
         .rpc_url
         .as_ref()
-        .ok_or("This command requires `--rpc-url`")?,
+        .ok_or_else(|| anyhow!("This command requires `--rpc-url`"))?,
       options
         .cookie_file
         .as_ref()
         .map(|path| Auth::CookieFile(path.clone()))
         .unwrap_or(Auth::None),
-    )?;
+    )
+    .context("Failed to connect to RPC URL")?;
 
     Ok(Self {
       client,
-      database: Database::open(options)?,
+      database: Database::open(options).context("Failed to open database")?,
       sleep_until: Cell::new(Instant::now()),
     })
   }
@@ -45,17 +46,19 @@ impl Index {
   }
 
   fn client(&self) -> &Client {
-    let now = Instant::now();
+    if cfg!(target_os = "macos") {
+      let now = Instant::now();
 
-    let sleep_until = self.sleep_until.get();
+      let sleep_until = self.sleep_until.get();
 
-    if sleep_until > now {
-      std::thread::sleep(sleep_until - now);
-    }
+      if sleep_until > now {
+        std::thread::sleep(sleep_until - now);
+      }
 
-    self
-      .sleep_until
-      .set(Instant::now() + Duration::from_millis(2));
+      self
+        .sleep_until
+        .set(Instant::now() + Duration::from_millis(2));
+    }
 
     &self.client
   }
@@ -108,7 +111,7 @@ impl Index {
         let prev_hash = wtx.blockhash_at_height(prev_height)?.unwrap();
 
         if prev_hash != block.header.prev_blockhash.as_ref() {
-          return Err("Reorg detected at or before {prev_height}".into());
+          return Err(anyhow!("Reorg detected at or before {prev_height}"));
         }
       }
 
@@ -138,7 +141,7 @@ impl Index {
 
           let ordinal_ranges = wtx
             .get_ordinal_ranges(key.as_slice())?
-            .ok_or("Could not find outpoint in index")?;
+            .ok_or_else(|| anyhow!("Could not find outpoint in index"))?;
 
           let new = input_ordinal_ranges.len();
 
@@ -224,7 +227,7 @@ impl Index {
       while remaining > 0 {
         let range = input_ordinal_ranges
           .pop_front()
-          .ok_or("Insufficient inputs for transaction outputs")?;
+          .ok_or_else(|| anyhow!("Insufficient inputs for transaction outputs"))?;
 
         let count = range.1 - range.0;
 

src/key.rs

@@ -25,7 +25,7 @@ impl Key {
 
   pub(crate) fn decode(buffer: &[u8]) -> Result<Self> {
     if buffer.len() != 24 {
-      return Err("Buffer too small to decode key from".into());
+      return Err(anyhow!("Buffer too small to decode key from"));
     }
 
     Ok(Key {

src/main.rs

@@ -5,6 +5,7 @@ use {
     arguments::Arguments, bytes::Bytes, epoch::Epoch, height::Height, index::Index, key::Key,
     options::Options, ordinal::Ordinal, sat_point::SatPoint, subcommand::Subcommand,
   },
+  anyhow::{anyhow, Context, Error},
   bitcoin::{
     blockdata::constants::COIN_VALUE, consensus::Decodable, consensus::Encodable, Block, BlockHash,
     OutPoint, Transaction, Txid,
@@ -29,28 +30,27 @@ use {
   },
 };
 
+#[cfg(feature = "redb")]
+use redb_database::{Database, WriteTransaction};
+
+#[cfg(not(feature = "redb"))]
+use lmdb_database::{Database, WriteTransaction};
+
 mod arguments;
 mod bytes;
 mod epoch;
 mod height;
 mod index;
 mod key;
+#[cfg(not(feature = "redb"))]
+mod lmdb_database;
 mod options;
 mod ordinal;
-mod sat_point;
-mod subcommand;
-
 #[cfg(feature = "redb")]
 mod redb_database;
-#[cfg(feature = "redb")]
-use redb_database::{Database, WriteTransaction};
-
-#[cfg(not(feature = "redb"))]
-mod lmdb_database;
-#[cfg(not(feature = "redb"))]
-use lmdb_database::{Database, WriteTransaction};
+mod sat_point;
+mod subcommand;
 
-type Error = Box<dyn std::error::Error + Send + Sync>;
 type Result<T = (), E = Error> = std::result::Result<T, E>;
 
 static INTERRUPTS: AtomicU64 = AtomicU64::new(0);

src/subcommand/find.rs

@@ -23,7 +23,7 @@ impl Find {
         }
         Ok(())
       }
-      None => Err("Ordinal has not been mined as of index height".into()),
+      None => Err(anyhow!("Ordinal has not been mined as of index height")),
     }
   }
 }

src/subcommand/list.rs

@@ -16,7 +16,7 @@ impl List {
         }
         Ok(())
       }
-      None => Err("Output not found".into()),
+      None => Err(anyhow!("Output not found")),
     }
   }
 }

src/subcommand/name.rs

@@ -8,7 +8,7 @@ pub(crate) struct Name {
 impl Name {
   pub(crate) fn run(self) -> Result {
     if self.name.is_empty() || self.name.chars().any(|c| !('a'..='z').contains(&c)) {
-      return Err("Invalid name".into());
+      return Err(anyhow!("Invalid name"));
     }
 
     let mut min = 0;
@@ -32,7 +32,7 @@ impl Name {
       }
 
       if max - min == 0 {
-        return Err("Name out of range".into());
+        return Err(anyhow!("Name out of range"));
       }
 
       guess = min + (max - min) / 2;

src/subcommand/traits.rs

@@ -8,7 +8,7 @@ pub(crate) struct Traits {
 impl Traits {
   pub(crate) fn run(self) -> Result {
     if self.ordinal > Ordinal::LAST {
-      return Err("Invalid ordinal".into());
+      return Err(anyhow!("Invalid ordinal"));
     }
 
     let n = self.ordinal.n();