feat: use storage abstraction

src/context.rs

@@ -7,12 +7,15 @@ use emily_client::apis::configuration::Configuration as EmilyConfig;
 use crate::bitcoin::node::BitcoinCoreClient;
 use crate::config::Settings;
 use crate::error::Error;
+use crate::storage::memory::{SharedStore, Store};
 
 /// Application context
 #[derive(Clone)]
 pub struct Context {
     bitcoin_client: BitcoinCoreClient,
     emily_config: Arc<EmilyConfig>,
+    storage: SharedStore,
+    settings: Arc<Settings>,
 }
 
 impl TryFrom<&Settings> for Context {
@@ -32,6 +35,8 @@ impl TryFrom<&Settings> for Context {
         Ok(Self {
             bitcoin_client,
             emily_config: Arc::new(emily_config),
+            storage: Store::new_shared(),
+            settings: Arc::new(value.clone()),
         })
     }
 }
@@ -46,4 +51,14 @@ impl Context {
     pub fn emily_config(&self) -> &EmilyConfig {
         &self.emily_config
     }
+
+    /// Get a reference to the storage
+    pub fn storage(&self) -> SharedStore {
+        self.storage.clone()
+    }
+
+    /// Get a reference to the config
+    pub fn settings(&self) -> &Settings {
+        &self.settings
+    }
 }

src/deposit_monitor.rs

@@ -1,64 +1,20 @@
 //! Module to monitor for pending deposits
 
-use std::collections::HashMap;
 use std::num::NonZeroUsize;
 use std::str::FromStr as _;
 
-use bitcoin::{BlockHash, ScriptBuf, Txid};
+use bitcoin::{BlockHash, Txid};
 use emily_client::models::CreateDepositRequestBody;
 use lru::LruCache;
-use sbtc::deposits::{DepositScriptInputs, ReclaimScriptInputs};
 
 use crate::bitcoin::{BlockRef, Utxo};
-use crate::config::MonitoredDepositConfig;
 use crate::context::Context;
 use crate::error::Error;
-
-/// A deposit address to monitor
-#[derive(Debug, Clone)]
-pub struct MonitoredDeposit {
-    /// Monitored deposit alias
-    pub alias: String,
-    /// Deposit script inputs
-    pub deposit_script_inputs: DepositScriptInputs,
-    /// Reclaim script inputs
-    pub reclaim_script_inputs: ReclaimScriptInputs,
-}
-
-impl MonitoredDeposit {
-    /// Get the scriptPubKey for this deposit address
-    pub fn to_script_pubkey(&self) -> ScriptBuf {
-        sbtc::deposits::to_script_pubkey(
-            self.deposit_script_inputs.deposit_script(),
-            self.reclaim_script_inputs.reclaim_script(),
-        )
-    }
-}
-
-impl TryFrom<(&String, &MonitoredDepositConfig)> for MonitoredDeposit {
-    type Error = Error;
-
-    fn try_from((alias, deposit): (&String, &MonitoredDepositConfig)) -> Result<Self, Self::Error> {
-        let deposit = deposit.clone();
-        Ok(MonitoredDeposit {
-            alias: alias.clone(),
-            deposit_script_inputs: DepositScriptInputs {
-                signers_public_key: deposit.signers_xonly,
-                recipient: deposit.recipient,
-                max_fee: deposit.max_fee,
-            },
-            reclaim_script_inputs: ReclaimScriptInputs::try_new(
-                deposit.lock_time,
-                deposit.reclaim_script,
-            )?,
-        })
-    }
-}
+use crate::storage::Storage as _;
 
 /// Deposit monitor
 pub struct DepositMonitor {
     context: Context,
-    monitored: HashMap<ScriptBuf, MonitoredDeposit>,
     tx_hex_cache: LruCache<(Txid, BlockHash), String>,
     created_deposits: LruCache<(Txid, u32), ()>,
 }
@@ -75,15 +31,9 @@ const CREATED_DEPOSITS_CACHE_SIZE: NonZeroUsize =
 
 impl DepositMonitor {
     /// Creates a new `DepositMonitor`
-    pub fn new(context: Context, monitored: Vec<MonitoredDeposit>) -> Self {
-        let monitored = monitored
-            .into_iter()
-            .map(|m| (m.to_script_pubkey(), m))
-            .collect();
-
+    pub fn new(context: Context) -> Self {
         Self {
             context,
-            monitored,
             tx_hex_cache: LruCache::new(TX_HEX_CACHE_SIZE),
             created_deposits: LruCache::new(CREATED_DEPOSITS_CACHE_SIZE),
         }
@@ -96,8 +46,9 @@ impl DepositMonitor {
         chain_tip: &BlockRef,
     ) -> Result<CreateDepositRequestBody, Error> {
         let monitored_deposit = self
-            .monitored
-            .get(&utxo.script_pub_key)
+            .context
+            .storage()
+            .get_by_script(&utxo.script_pub_key)?
             .ok_or_else(|| Error::MissingMonitoredDeposit(utxo.script_pub_key.clone()))?;
 
         let unlocking_time =
@@ -137,10 +88,13 @@ impl DepositMonitor {
         &mut self,
         chain_tip: &BlockRef,
     ) -> Result<Vec<CreateDepositRequestBody>, Error> {
-        let utxos = self
-            .context
-            .bitcoin_client()
-            .get_utxos(self.monitored.keys())?;
+        let script_pubkeys = self.context.storage().get_scripts()?;
+        if script_pubkeys.is_empty() {
+            return Ok(Vec::new());
+        }
+
+        // TODO: batch the get_utxos call
+        let utxos = self.context.bitcoin_client().get_utxos(&script_pubkeys)?;
 
         let create_deposits = utxos
             .iter()

src/error.rs

@@ -31,6 +31,10 @@ pub enum Error {
     #[error("could not parse the provided URL: {0}")]
     InvalidUrl(#[source] url::ParseError),
 
+    /// Poisoned mutex
+    #[error("poisoned mutex")]
+    PoisonedMutex,
+
     /// No chain tip found.
     #[error("no bitcoin chain tip")]
     NoChainTip,

src/lib.rs

@@ -8,6 +8,7 @@ pub mod deposit_monitor;
 pub mod error;
 pub mod logging;
 pub mod stacks;
+pub mod storage;
 
 #[cfg(any(test, feature = "testing"))]
 pub mod testing;

src/main.rs

@@ -7,9 +7,11 @@ use emily_client::apis::deposit_api;
 use spox::bitcoin::BlockRef;
 use spox::config::Settings;
 use spox::context::Context;
-use spox::deposit_monitor::{DepositMonitor, MonitoredDeposit};
+use spox::deposit_monitor::DepositMonitor;
 use spox::error::Error;
 use spox::stacks::node::StacksClient;
+use spox::storage::Storage;
+use spox::storage::model::{MonitoredDeposit, MonitoredDepositSource};
 
 #[derive(Debug, Clone, Copy, ValueEnum)]
 enum LogOutputFormat {
@@ -146,7 +148,10 @@ async fn get_deposit_address(
 ) -> Result<(), Box<dyn std::error::Error>> {
     for deposit in monitored {
         let address = Address::from_script(&deposit.to_script_pubkey(), args.network)?;
-        println!("{}: {}", deposit.alias, address);
+        match &deposit.source {
+            MonitoredDepositSource::Config(alias) => println!("{alias}: {address}"),
+            MonitoredDepositSource::Registry(id) => println!("id={id}: {address}"),
+        }
     }
     Ok(())
 }
@@ -182,7 +187,12 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     let context = Context::try_from(&config)?;
 
-    let mut deposit_monitor = DepositMonitor::new(context.clone(), monitored);
+    let store = context.storage();
+    for monitored_deposit in monitored {
+        store.add(monitored_deposit)?;
+    }
+
+    let mut deposit_monitor = DepositMonitor::new(context.clone());
 
     runloop(context, &mut deposit_monitor, config.polling_interval).await;
 

src/storage/memory.rs

@@ -0,0 +1,71 @@
+//! In-memory implementation of the Storage trait
+
+use std::{
+    collections::HashMap,
+    sync::{Arc, Mutex},
+};
+
+use bitcoin::ScriptBuf;
+
+use crate::{
+    error::Error,
+    storage::{Storage, model::MonitoredDeposit},
+};
+
+/// A store wrapped in an Arc<Mutex<...>> for interior mutability
+pub type SharedStore = Arc<Mutex<Store>>;
+
+/// In-memory store
+#[derive(Debug, Clone, Default)]
+pub struct Store {
+    last_next_address_id: u64,
+    monitored: HashMap<ScriptBuf, MonitoredDeposit>,
+}
+
+impl Store {
+    /// Create an empty store wrapped in an Arc<Mutex<...>>
+    pub fn new_shared() -> SharedStore {
+        Arc::new(Mutex::new(Self::default()))
+    }
+}
+
+/// Storage trait implementation for the in-memory store
+impl Storage for SharedStore {
+    /// Add a monitored deposit. If the script pubkey already exists it's a nop.
+    fn add(&self, monitored_deposit: MonitoredDeposit) -> Result<(), Error> {
+        let mut store = self.lock().map_err(|_| Error::PoisonedMutex)?;
+
+        let key = monitored_deposit.to_script_pubkey();
+        store.monitored.entry(key).or_insert(monitored_deposit);
+        Ok(())
+    }
+
+    /// Get a monitored deposit by script pubkey.
+    fn get_by_script(&self, script: &ScriptBuf) -> Result<Option<MonitoredDeposit>, Error> {
+        let store = self.lock().map_err(|_| Error::PoisonedMutex)?;
+
+        Ok(store.monitored.get(script).cloned())
+    }
+
+    /// Get the script pubkeys for monitored deposits
+    fn get_scripts(&self) -> Result<Vec<ScriptBuf>, Error> {
+        let store = self.lock().map_err(|_| Error::PoisonedMutex)?;
+
+        Ok(store.monitored.keys().cloned().collect())
+    }
+
+    /// Get the last next-address-id from the registry
+    fn get_last_next_address_id(&self) -> Result<u64, Error> {
+        let store = self.lock().map_err(|_| Error::PoisonedMutex)?;
+
+        Ok(store.last_next_address_id)
+    }
+
+    /// Set the last next-address-id from the registry
+    fn set_last_next_address_id(&self, next_address_id: u64) -> Result<(), Error> {
+        let mut store = self.lock().map_err(|_| Error::PoisonedMutex)?;
+
+        store.last_next_address_id = next_address_id;
+        Ok(())
+    }
+}

src/storage/mod.rs

@@ -0,0 +1,26 @@
+//! Contains functionality for interacting with the storage abstraction
+
+use bitcoin::ScriptBuf;
+
+use crate::error::Error;
+
+pub mod memory;
+pub mod model;
+
+/// Interface for spox storage.
+pub trait Storage {
+    /// Add a monitored deposit. If the script pubkey already exists it's a nop.
+    fn add(&self, monitored_deposit: model::MonitoredDeposit) -> Result<(), Error>;
+
+    /// Get a monitored deposit by script pubkey.
+    fn get_by_script(&self, script: &ScriptBuf) -> Result<Option<model::MonitoredDeposit>, Error>;
+
+    /// Get the script pubkeys for monitored deposits
+    fn get_scripts(&self) -> Result<Vec<ScriptBuf>, Error>;
+
+    /// Get the last next-address-id from the registry
+    fn get_last_next_address_id(&self) -> Result<u64, Error>;
+
+    /// Set the last next-address-id from the registry
+    fn set_last_next_address_id(&self, next_address_id: u64) -> Result<(), Error>;
+}

src/storage/model.rs

@@ -0,0 +1,56 @@
+//! Data models used in spox.
+
+use bitcoin::ScriptBuf;
+use sbtc::deposits::{DepositScriptInputs, ReclaimScriptInputs};
+
+use crate::{config::MonitoredDepositConfig, error::Error};
+
+/// The source for a deposit
+#[derive(Debug, Clone)]
+pub enum MonitoredDepositSource {
+    /// Address is configured in the config file (with this alias)
+    Config(String),
+    /// Address is registered on the smart contract registry (with this ID)
+    Registry(u64),
+}
+
+/// A deposit address to monitor
+#[derive(Debug, Clone)]
+pub struct MonitoredDeposit {
+    /// Monitored deposit source
+    pub source: MonitoredDepositSource,
+    /// Deposit script inputs
+    pub deposit_script_inputs: DepositScriptInputs,
+    /// Reclaim script inputs
+    pub reclaim_script_inputs: ReclaimScriptInputs,
+}
+
+impl MonitoredDeposit {
+    /// Get the scriptPubKey for this deposit address
+    pub fn to_script_pubkey(&self) -> ScriptBuf {
+        sbtc::deposits::to_script_pubkey(
+            self.deposit_script_inputs.deposit_script(),
+            self.reclaim_script_inputs.reclaim_script(),
+        )
+    }
+}
+
+impl TryFrom<(&String, &MonitoredDepositConfig)> for MonitoredDeposit {
+    type Error = Error;
+
+    fn try_from((alias, deposit): (&String, &MonitoredDepositConfig)) -> Result<Self, Self::Error> {
+        let deposit = deposit.clone();
+        Ok(MonitoredDeposit {
+            source: MonitoredDepositSource::Config(alias.clone()),
+            deposit_script_inputs: DepositScriptInputs {
+                signers_public_key: deposit.signers_xonly,
+                recipient: deposit.recipient,
+                max_fee: deposit.max_fee,
+            },
+            reclaim_script_inputs: ReclaimScriptInputs::try_new(
+                deposit.lock_time,
+                deposit.reclaim_script,
+            )?,
+        })
+    }
+}

tests/README.md

@@ -25,7 +25,8 @@ bootstrap create a donation for them.
 ```bash
 # From sBTC repo
 make devenv-up
-cargo run -p signer --bin demo-cli donation --amount 10000
+# Wait for devenv bootstrap, then fund the sBTC signers
+cargo run -p signer --bin demo-cli donation
 ```
 
 ## Fund the stackers

tests/solo/spox.toml

@@ -10,11 +10,11 @@ signers_xonly = "000000000000000000000000000000000000000000000000000000000000000
 recipient = "ST2FQWJMF9CGPW34ZWK8FEPNK072NEV1VKRNBBMJ9"
 max_fee = 5000
 lock_time = 100
-reclaim_script = ""
+reclaim_script = "7551" # OP_DROP OP_TRUE
 
 [deposit.bob]
 signers_xonly = "0000000000000000000000000000000000000000000000000000000000000001"
 recipient = "ST2BMYXHQ63YP410C57808B1K9APN38KDQM9A0E6S"
 max_fee = 2000
 lock_time = 200
-reclaim_script = ""
+reclaim_script = "7500" # OP_DROP OP_FALSE