Allow rpc_user and rpc_pass in config file

src/config.rs

@@ -3,6 +3,8 @@ use super::*;
 #[derive(Deserialize, Default, PartialEq, Debug)]
 pub(crate) struct Config {
   pub(crate) hidden: HashSet<InscriptionId>,
+  pub(crate) rpc_user: Option<String>,
+  pub(crate) rpc_pass: Option<String>,
 }
 
 impl Config {
@@ -27,6 +29,8 @@ mod tests {
 
     let config = Config {
       hidden: iter::once(a).collect(),
+      rpc_user: None,
+      rpc_pass: None,
     };
 
     assert!(config.is_hidden(a));

src/index.rs

@@ -9,7 +9,7 @@ use {
   super::*,
   crate::wallet::Wallet,
   bitcoin::BlockHeader,
-  bitcoincore_rpc::{json::GetBlockHeaderResult, Auth, Client},
+  bitcoincore_rpc::{json::GetBlockHeaderResult, Client},
   chrono::SubsecRound,
   indicatif::{ProgressBar, ProgressStyle},
   log::log_enabled,
@@ -44,16 +44,15 @@ define_table! { STATISTIC_TO_COUNT, u64, u64 }
 define_table! { WRITE_TRANSACTION_STARTING_BLOCK_COUNT_TO_TIMESTAMP, u64, u128 }
 
 pub(crate) struct Index {
-  auth: Auth,
   client: Client,
   database: Database,
   path: PathBuf,
   first_inscription_height: u64,
   genesis_block_coinbase_transaction: Transaction,
   genesis_block_coinbase_txid: Txid,
   height_limit: Option<u64>,
+  options: Options,
   reorged: AtomicBool,
-  rpc_url: String,
 }
 
 #[derive(Debug, PartialEq)]
@@ -133,17 +132,7 @@ impl<T> BitcoinCoreRpcResultExt<T> for Result<T, bitcoincore_rpc::Error> {
 
 impl Index {
   pub(crate) fn open(options: &Options) -> Result<Self> {
-    let rpc_url = options.rpc_url();
-    let cookie_file = options.cookie_file()?;
-
-    log::info!(
-      "Connecting to Bitcoin Core RPC server at {rpc_url} using credentials from `{}`",
-      cookie_file.display()
-    );
-
-    let auth = Auth::CookieFile(cookie_file);
-
-    let client = Client::new(&rpc_url, auth.clone()).context("failed to connect to RPC URL")?;
+    let client = options.bitcoin_rpc_client()?;
 
     let data_dir = options.data_dir()?;
 
@@ -232,15 +221,14 @@ impl Index {
 
     Ok(Self {
       genesis_block_coinbase_txid: genesis_block_coinbase_transaction.txid(),
-      auth,
       client,
       database,
       path,
       first_inscription_height: options.first_inscription_height(),
       genesis_block_coinbase_transaction,
       height_limit: options.height_limit,
       reorged: AtomicBool::new(false),
-      rpc_url,
+      options: options.clone(),
     })
   }
 
@@ -568,7 +556,6 @@ impl Index {
           .open_table(SATPOINT_TO_INSCRIPTION_ID)?,
         outpoint,
       )?
-      .into_iter()
       .map(|(_satpoint, inscription_id)| inscription_id)
       .collect(),
     )

src/index/fetcher.rs

@@ -1,7 +1,7 @@
 use {
+  crate::Options,
   anyhow::{anyhow, Result},
   bitcoin::{Transaction, Txid},
-  bitcoincore_rpc::Auth,
   hyper::{client::HttpConnector, Body, Client, Method, Request, Uri},
   serde::Deserialize,
   serde_json::{json, Value},
@@ -27,22 +27,18 @@ struct JsonError {
 }
 
 impl Fetcher {
-  pub(crate) fn new(url: &str, auth: Auth) -> Result<Self> {
-    if auth == Auth::None {
-      return Err(anyhow!("No rpc authentication provided"));
-    }
-
+  pub(crate) fn new(options: &Options) -> Result<Self> {
     let client = Client::new();
 
-    let url = if url.starts_with("http://") {
-      url.to_string()
+    let url = if options.rpc_url().starts_with("http://") {
+      options.rpc_url()
     } else {
-      "http://".to_string() + url
+      "http://".to_string() + &options.rpc_url()
     };
 
     let url = Uri::try_from(&url).map_err(|e| anyhow!("Invalid rpc url {url}: {e}"))?;
 
-    let (user, password) = auth.get_user_pass()?;
+    let (user, password) = options.auth().get_user_pass()?;
     let auth = format!("{}:{}", user.unwrap(), password.unwrap());
     let auth = format!("Basic {}", &base64::encode(auth));
     Ok(Fetcher { client, url, auth })

src/index/updater.rs

@@ -184,8 +184,7 @@ impl Updater {
 
     let height_limit = index.height_limit;
 
-    let client =
-      Client::new(&index.rpc_url, index.auth.clone()).context("failed to connect to RPC URL")?;
+    let client = index.options.bitcoin_rpc_client()?;
 
     let first_inscription_height = index.first_inscription_height;
 
@@ -262,7 +261,7 @@ impl Updater {
   }
 
   fn spawn_fetcher(index: &Index) -> Result<(Sender<OutPoint>, Receiver<u64>)> {
-    let fetcher = Fetcher::new(&index.rpc_url, index.auth.clone())?;
+    let fetcher = Fetcher::new(&index.options)?;
 
     // 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;

src/options.rs

@@ -37,6 +37,10 @@ pub(crate) struct Options {
   pub(crate) index_sats: bool,
   #[clap(long, short, help = "Use regtest. Equivalent to `--chain regtest`.")]
   pub(crate) regtest: bool,
+  #[clap(long, help = "Authenticate to Bitcoin Core RPC as <RPC_USER>.")]
+  pub(crate) rpc_user: Option<String>,
+  #[clap(long, help = "Authenticate to Bitcoin Core RPC with <RPC_PASS>.")]
+  pub(crate) rpc_pass: Option<String>,
   #[clap(long, help = "Connect to Bitcoin Core RPC at <RPC_URL>.")]
   pub(crate) rpc_url: Option<String>,
   #[clap(long, short, help = "Use signet. Equivalent to `--chain signet`.")]
@@ -136,25 +140,50 @@ impl Options {
     )
   }
 
-  pub(crate) fn bitcoin_rpc_client(&self) -> Result<Client> {
-    let cookie_file = self
-      .cookie_file()
-      .map_err(|err| anyhow!("failed to get cookie file path: {err}"))?;
+  fn derive_var(
+    arg: Option<OsString>,
+    env: Option<OsString>,
+    config: Option<OsString>,
+    default: Option<OsString>,
+  ) -> Option<OsString> {
+    arg.or(env).or(config).or(default)
+  }
 
-    let rpc_url = self.rpc_url();
+  pub(crate) fn auth(&self) -> Auth {
+    log::info!("Connecting to Bitcoin Core at {}", self.rpc_url());
+
+    let config = self.load_config().unwrap();
+
+    let rpc_user = Options::derive_var(
+      self.rpc_user.as_ref().map(|string| string.into()),
+      env::var_os("RPC_USER"),
+      config.rpc_user.map(|string| string.into()),
+      None,
+    );
 
-    log::info!(
-      "Connecting to Bitcoin Core RPC server at {rpc_url} using credentials from `{}`",
-      cookie_file.display()
+    let rpc_pass = Options::derive_var(
+      self.rpc_pass.as_ref().map(|string| string.into()),
+      env::var_os("RPC_PASS"),
+      config.rpc_pass.map(|string| string.into()),
+      None,
     );
 
-    let client =
-      Client::new(&rpc_url, Auth::CookieFile(cookie_file.clone())).with_context(|| {
-        format!(
-          "failed to connect to Bitcoin Core RPC at {rpc_url} using cookie file {}",
-          cookie_file.display()
-        )
-      })?;
+    match (rpc_user, rpc_pass) {
+      (Some(rpc_user), Some(rpc_pass)) => Auth::UserPass(
+        rpc_user.into_string().expect("rpc_user is invalid UTF-8"),
+        rpc_pass.into_string().expect("rpc_pass is invalid UTF-8"),
+      ),
+      _ => Auth::CookieFile(self.cookie_file().unwrap()),
+    }
+  }
+
+  pub(crate) fn bitcoin_rpc_client(&self) -> Result<Client> {
+    let rpc_url = self.rpc_url();
+
+    let auth = self.auth();
+
+    let client = Client::new(&rpc_url, auth)
+      .with_context(|| format!("failed to connect to Bitcoin Core RPC at {rpc_url}"))?;
 
     let rpc_chain = match client.get_blockchain_info()?.chain.as_str() {
       "main" => Chain::Mainnet,
@@ -561,6 +590,39 @@ mod tests {
         .unwrap(),
       Config {
         hidden: iter::once(id).collect(),
+        rpc_user: None,
+        rpc_pass: None,
+      }
+    );
+  }
+
+  #[test]
+  fn test_rpc_user_and_pass_flags() {
+    let options =
+      Arguments::try_parse_from(["ord", "--rpc-user", "foo", "--rpc-pass", "bar", "index"])
+        .unwrap()
+        .options;
+
+    assert_eq!(options.rpc_user.unwrap(), "foo".to_string());
+    assert_eq!(options.rpc_pass.unwrap(), "bar".to_string());
+  }
+
+  #[test]
+  fn config_with_rpc_user_pass() {
+    let tempdir = TempDir::new().unwrap();
+    let path = tempdir.path().join("ord.yaml");
+    fs::write(&path, "hidden:\nrpc_user: foo\nrpc_pass: bar").unwrap();
+
+    assert_eq!(
+      Arguments::try_parse_from(["ord", "--config", path.to_str().unwrap(), "index",])
+        .unwrap()
+        .options
+        .load_config()
+        .unwrap(),
+      Config {
+        hidden: HashSet::new(),
+        rpc_user: Some("foo".into()),
+        rpc_pass: Some("bar".into()),
       }
     );
   }
@@ -592,7 +654,48 @@ mod tests {
       .unwrap(),
       Config {
         hidden: iter::once(id).collect(),
+        rpc_user: None,
+        rpc_pass: None,
       }
     );
   }
+
+  #[test]
+  fn test_derive_var() {
+    assert_eq!(Options::derive_var(None, None, None, None), None);
+
+    assert_eq!(
+      Options::derive_var(None, None, None, Some("foo".into())),
+      Some("foo".into())
+    );
+
+    assert_eq!(
+      Options::derive_var(None, None, Some("bar".into()), Some("foo".into())),
+      Some("bar".into())
+    );
+
+    assert_eq!(
+      Options::derive_var(
+        None,
+        Some("baz".into()),
+        Some("bar".into()),
+        Some("foo".into())
+      ),
+      Some("baz".into())
+    );
+
+    assert_eq!(
+      Options::derive_var(
+        Some("qux".into()),
+        Some("baz".into()),
+        Some("bar".into()),
+        Some("foo".into())
+      ),
+      Some("qux".into())
+    );
+
+    assert!(
+      Options::derive_var(Some("qux".into()), None, None, Some("foo".into())) != Some("foo".into())
+    );
+  }
 }