Allow configuring chain with config file

src/arguments.rs

@@ -21,6 +21,6 @@ pub(crate) struct Arguments {
 
 impl Arguments {
   pub(crate) fn run(self) -> SubcommandResult {
-    self.subcommand.run(self.options)
+    self.subcommand.run(Settings::new(self.options)?)
   }
 }

src/chain.rs

@@ -108,3 +108,30 @@ impl Display for Chain {
     )
   }
 }
+
+impl FromStr for Chain {
+  type Err = Error;
+
+  fn from_str(s: &str) -> Result<Self, Self::Err> {
+    match s {
+      "mainnet" => Ok(Self::Mainnet),
+      "regtest" => Ok(Self::Regtest),
+      "signet" => Ok(Self::Signet),
+      "testnet" => Ok(Self::Testnet),
+      _ => bail!("invalid chain: {s}"),
+    }
+  }
+}
+
+#[cfg(test)]
+mod tests {
+  use super::*;
+
+  #[test]
+  fn from_str() {
+    assert_eq!("mainnet".parse::<Chain>().unwrap(), Chain::Mainnet);
+    assert_eq!("regtest".parse::<Chain>().unwrap(), Chain::Regtest);
+    assert_eq!("signet".parse::<Chain>().unwrap(), Chain::Signet);
+    assert_eq!("testnet".parse::<Chain>().unwrap(), Chain::Testnet);
+  }
+}

src/config.rs

@@ -1,11 +1,12 @@
 use super::*;
 
-#[derive(Deserialize, Default, PartialEq, Debug)]
+#[derive(Deserialize, Default, PartialEq, Debug, Clone)]
 #[serde(deny_unknown_fields)]
 pub(crate) struct Config {
-  pub(crate) hidden: HashSet<InscriptionId>,
   pub(crate) bitcoin_rpc_pass: Option<String>,
   pub(crate) bitcoin_rpc_user: Option<String>,
+  pub(crate) chain: Option<Chain>,
+  pub(crate) hidden: HashSet<InscriptionId>,
 }
 
 impl Config {

src/index.rs

@@ -213,27 +213,28 @@ pub struct Index {
   index_sats: bool,
   index_spent_sats: bool,
   index_transactions: bool,
-  options: Options,
+  settings: Settings,
   path: PathBuf,
   started: DateTime<Utc>,
   unrecoverably_reorged: AtomicBool,
 }
 
 impl Index {
-  pub fn open(options: &Options) -> Result<Self> {
-    Index::open_with_event_sender(options, None)
+  pub fn open(settings: &Settings) -> Result<Self> {
+    Index::open_with_event_sender(settings, None)
   }
 
   pub fn open_with_event_sender(
-    options: &Options,
+    settings: &Settings,
     event_sender: Option<tokio::sync::mpsc::Sender<Event>>,
   ) -> Result<Self> {
-    let client = options.bitcoin_rpc_client(None)?;
+    let client = settings.bitcoin_rpc_client(None)?;
 
-    let path = options
+    let path = settings
+      .options
       .index
       .clone()
-      .unwrap_or(options.data_dir().clone().join("index.redb"));
+      .unwrap_or_else(|| settings.data_dir().clone().join("index.redb"));
 
     if let Err(err) = fs::create_dir_all(path.parent().unwrap()) {
       bail!(
@@ -242,7 +243,7 @@ impl Index {
       );
     }
 
-    let db_cache_size = match options.db_cache_size {
+    let db_cache_size = match settings.options.db_cache_size {
       Some(db_cache_size) => db_cache_size,
       None => {
         let mut sys = System::new();
@@ -349,32 +350,32 @@ impl Index {
           let mut outpoint_to_sat_ranges = tx.open_table(OUTPOINT_TO_SAT_RANGES)?;
           let mut statistics = tx.open_table(STATISTIC_TO_COUNT)?;
 
-          if options.index_sats {
+          if settings.options.index_sats {
             outpoint_to_sat_ranges.insert(&OutPoint::null().store(), [].as_slice())?;
           }
 
           Self::set_statistic(
             &mut statistics,
             Statistic::IndexRunes,
-            u64::from(options.index_runes()),
+            u64::from(settings.index_runes()),
           )?;
 
           Self::set_statistic(
             &mut statistics,
             Statistic::IndexSats,
-            u64::from(options.index_sats || options.index_spent_sats),
+            u64::from(settings.options.index_sats || settings.options.index_spent_sats),
           )?;
 
           Self::set_statistic(
             &mut statistics,
             Statistic::IndexSpentSats,
-            u64::from(options.index_spent_sats),
+            u64::from(settings.options.index_spent_sats),
           )?;
 
           Self::set_statistic(
             &mut statistics,
             Statistic::IndexTransactions,
-            u64::from(options.index_transactions),
+            u64::from(settings.options.index_transactions),
           )?;
 
           Self::set_statistic(&mut statistics, Statistic::Schema, SCHEMA_VERSION)?;
@@ -402,22 +403,22 @@ impl Index {
     }
 
     let genesis_block_coinbase_transaction =
-      options.chain().genesis_block().coinbase().unwrap().clone();
+      settings.chain().genesis_block().coinbase().unwrap().clone();
 
     Ok(Self {
       genesis_block_coinbase_txid: genesis_block_coinbase_transaction.txid(),
       client,
       database,
       durability,
       event_sender,
-      first_inscription_height: options.first_inscription_height(),
+      first_inscription_height: settings.first_inscription_height(),
       genesis_block_coinbase_transaction,
-      height_limit: options.height_limit,
+      height_limit: settings.options.height_limit,
       index_runes,
       index_sats,
       index_spent_sats,
       index_transactions,
-      options: options.clone(),
+      settings: settings.clone(),
       path,
       started: Utc::now(),
       unrecoverably_reorged: AtomicBool::new(false),
@@ -486,14 +487,14 @@ impl Index {
 
     Ok(StatusHtml {
       blessed_inscriptions,
-      chain: self.options.chain(),
+      chain: self.settings.chain(),
       content_type_counts,
       cursed_inscriptions,
       height,
       inscriptions: blessed_inscriptions + cursed_inscriptions,
       lost_sats: statistic(Statistic::LostSats)?,
       minimum_rune_for_next_block: Rune::minimum_at_height(
-        self.options.chain(),
+        self.settings.chain(),
         Height(next_height),
       ),
       rune_index: statistic(Statistic::IndexRunes)? != 0,
@@ -670,7 +671,7 @@ impl Index {
             .nth(satpoint.outpoint.vout.try_into().unwrap())
             .unwrap();
           self
-            .options
+            .settings
             .chain()
             .address_from_script(&output.script_pubkey)
             .map(|address| address.to_string())
@@ -1482,7 +1483,7 @@ impl Index {
   pub(crate) fn is_output_spent(&self, outpoint: OutPoint) -> Result<bool> {
     Ok(
       outpoint != OutPoint::null()
-        && outpoint != self.options.chain().genesis_coinbase_outpoint()
+        && outpoint != self.settings.chain().genesis_coinbase_outpoint()
         && self
           .client
           .get_tx_out(&outpoint.txid, outpoint.vout, Some(false))?
@@ -1495,7 +1496,7 @@ impl Index {
       return Ok(true);
     }
 
-    if outpoint == self.options.chain().genesis_coinbase_outpoint() {
+    if outpoint == self.settings.chain().genesis_coinbase_outpoint() {
       return Ok(true);
     }
 

src/index/fetcher.rs

@@ -25,18 +25,18 @@ struct JsonError {
 }
 
 impl Fetcher {
-  pub(crate) fn new(options: &Options) -> Result<Self> {
+  pub(crate) fn new(settings: &Settings) -> Result<Self> {
     let client = Client::new();
 
-    let url = if options.rpc_url(None).starts_with("http://") {
-      options.rpc_url(None)
+    let url = if settings.rpc_url(None).starts_with("http://") {
+      settings.rpc_url(None)
     } else {
-      "http://".to_string() + &options.rpc_url(None)
+      "http://".to_string() + &settings.rpc_url(None)
     };
 
     let url = Uri::try_from(&url).map_err(|e| anyhow!("Invalid rpc url {url}: {e}"))?;
 
-    let (user, password) = options.auth()?.get_user_pass()?;
+    let (user, password) = settings.auth()?.get_user_pass()?;
     let auth = format!("{}:{}", user.unwrap(), password.unwrap());
     let auth = format!(
       "Basic {}",

src/index/reorg.rs

@@ -86,7 +86,7 @@ impl Reorg {
     if (height < SAVEPOINT_INTERVAL || height % SAVEPOINT_INTERVAL == 0)
       && u32::try_from(
         index
-          .options
+          .settings
           .bitcoin_rpc_client(None)?
           .get_blockchain_info()?
           .headers,

src/index/testing.rs

@@ -33,7 +33,12 @@ impl ContextBuilder {
     ];
 
     let options = Options::try_parse_from(command.into_iter().chain(self.args)).unwrap();
-    let index = Index::open_with_event_sender(&options, self.event_sender)?;
+    let settings = Settings {
+      chain: self.chain,
+      config: Default::default(),
+      options,
+    };
+    let index = Index::open_with_event_sender(&settings, self.event_sender)?;
     index.update().unwrap();
 
     Ok(Context {

src/index/updater.rs

@@ -164,7 +164,7 @@ impl<'index> Updater<'_> {
 
     let height_limit = index.height_limit;
 
-    let client = index.options.bitcoin_rpc_client(None)?;
+    let client = index.settings.bitcoin_rpc_client(None)?;
 
     let first_inscription_height = index.first_inscription_height;
 
@@ -241,7 +241,7 @@ impl<'index> Updater<'_> {
   }
 
   fn spawn_fetcher(index: &Index) -> Result<(Sender<OutPoint>, Receiver<u64>)> {
-    let fetcher = Fetcher::new(&index.options)?;
+    let fetcher = Fetcher::new(&index.settings)?;
 
     // Not sure if any block has more than 20k inputs, but none so far after first inscription block
     const CHANNEL_BUFFER_SIZE: usize = 20_000;
@@ -339,7 +339,7 @@ impl<'index> Updater<'_> {
     let mut outpoint_to_value = wtx.open_table(OUTPOINT_TO_VALUE)?;
 
     let index_inscriptions = self.height >= self.index.first_inscription_height
-      && !self.index.options.no_index_inscriptions;
+      && !self.index.settings.options.no_index_inscriptions;
 
     if index_inscriptions {
       // Send all missing input outpoints to be fetched right away
@@ -423,7 +423,7 @@ impl<'index> Updater<'_> {
 
     let mut inscription_updater = InscriptionUpdater {
       blessed_inscription_count,
-      chain: self.index.options.chain(),
+      chain: self.index.settings.chain(),
       content_type_to_count: &mut content_type_to_count,
       cursed_inscription_count,
       event_sender: self.index.event_sender.as_ref(),
@@ -583,7 +583,7 @@ impl<'index> Updater<'_> {
       &inscription_updater.unbound_inscriptions,
     )?;
 
-    if self.index.index_runes && self.height >= self.index.options.first_rune_height() {
+    if self.index.index_runes && self.height >= self.index.settings.first_rune_height() {
       let mut outpoint_to_rune_balances = wtx.open_table(OUTPOINT_TO_RUNE_BALANCES)?;
       let mut rune_id_to_rune_entry = wtx.open_table(RUNE_ID_TO_RUNE_ENTRY)?;
       let mut rune_to_rune_id = wtx.open_table(RUNE_TO_RUNE_ID)?;
@@ -599,7 +599,7 @@ impl<'index> Updater<'_> {
         height: self.height,
         id_to_entry: &mut rune_id_to_rune_entry,
         inscription_id_to_sequence_number: &mut inscription_id_to_sequence_number,
-        minimum: Rune::minimum_at_height(self.index.options.chain(), Height(self.height)),
+        minimum: Rune::minimum_at_height(self.index.settings.chain(), Height(self.height)),
         outpoint_to_balances: &mut outpoint_to_rune_balances,
         rune_to_id: &mut rune_to_rune_id,
         runes,

src/lib.rs

@@ -23,6 +23,7 @@ use {
     },
     representation::Representation,
     runes::{Etching, Pile, SpacedRune},
+    settings::Settings,
     subcommand::{Subcommand, SubcommandResult},
     tally::Tally,
   },
@@ -94,13 +95,12 @@ mod test;
 use self::test::*;
 
 macro_rules! tprintln {
-    ($($arg:tt)*) => {
-
-      if cfg!(test) {
-        eprint!("==> ");
-        eprintln!($($arg)*);
-      }
-    };
+  ($($arg:tt)*) => {
+    if cfg!(test) {
+      eprint!("==> ");
+      eprintln!($($arg)*);
+    }
+  };
 }
 
 pub mod arguments;
@@ -117,6 +117,7 @@ pub mod outgoing;
 mod representation;
 pub mod runes;
 mod server_config;
+mod settings;
 pub mod subcommand;
 mod tally;
 pub mod templates;
@@ -186,10 +187,10 @@ fn unbound_outpoint() -> OutPoint {
   }
 }
 
-pub fn parse_ord_server_args(args: &str) -> (Options, crate::subcommand::server::Server) {
+pub fn parse_ord_server_args(args: &str) -> (Settings, crate::subcommand::server::Server) {
   match Arguments::try_parse_from(args.split_whitespace()) {
     Ok(arguments) => match arguments.subcommand {
-      Subcommand::Server(server) => (arguments.options, server),
+      Subcommand::Server(server) => (Settings::new(arguments.options).unwrap(), server),
       subcommand => panic!("unexpected subcommand: {subcommand:?}"),
     },
     Err(err) => panic!("error parsing arguments: {err}"),