Introduce DatabaseFactory trait

This is part of #486 to add multi-descriptor wallet support to BDK.

Author: evanlinjin

src/database/any.rs

@@ -425,3 +425,43 @@ impl ConfigurableDatabase for AnyDatabase {
 impl_from!((), AnyDatabaseConfig, Memory,);
 impl_from!(SledDbConfiguration, AnyDatabaseConfig, Sled, #[cfg(feature = "key-value-db")]);
 impl_from!(SqliteDbConfiguration, AnyDatabaseConfig, Sqlite, #[cfg(feature = "sqlite")]);
+
+/// Type that implements [`DatabaseFactory`] that builds [`AnyDatabase`].
+pub enum AnyDatabaseFactory {
+    /// Memory database factory
+    Memory(memory::MemoryDatabaseFactory),
+    #[cfg(feature = "key-value-db")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "key-value-db")))]
+    /// Key-value database factory
+    Sled(sled::Db),
+    #[cfg(feature = "sqlite")]
+    #[cfg_attr(docsrs, doc(cfg(feature = "sqlite")))]
+    /// Sqlite databae factory
+    Sqlite(sqlite::SqliteDatabaseFactory),
+}
+
+impl DatabaseFactory for AnyDatabaseFactory {
+    type Inner = AnyDatabase;
+
+    fn build_with_change(
+        &self,
+        descriptor: ExtendedDescriptor,
+        change_descriptor: Option<ExtendedDescriptor>,
+        network: Network,
+        secp: &SecpCtx,
+    ) -> Result<Self::Inner, Error> {
+        match self {
+            AnyDatabaseFactory::Memory(f) => f
+                .build_with_change(descriptor, change_descriptor, network, secp)
+                .map(Self::Inner::Memory),
+            #[cfg(feature = "key-value-db")]
+            AnyDatabaseFactory::Sled(f) => f
+                .build_with_change(descriptor, change_descriptor, network, secp)
+                .map(Self::Inner::Sled),
+            #[cfg(feature = "sqlite")]
+            AnyDatabaseFactory::Sqlite(f) => f
+                .build_with_change(descriptor, change_descriptor, network, secp)
+                .map(Self::Inner::Sqlite),
+        }
+    }
+}

src/database/keyvalue.rs

@@ -21,6 +21,9 @@ use crate::database::memory::MapKey;
 use crate::database::{BatchDatabase, BatchOperations, Database, SyncTime};
 use crate::error::Error;
 use crate::types::*;
+use crate::wallet::wallet_name_from_descriptor;
+
+use super::DatabaseFactory;
 
 macro_rules! impl_batch_operations {
     ( { $($after_insert:tt)* }, $process_delete:ident ) => {
@@ -402,6 +405,28 @@ impl BatchDatabase for Tree {
     }
 }
 
+/// A [`DatabaseFactory`] implementation that builds [`Tree`]
+impl DatabaseFactory for sled::Db {
+    type Inner = sled::Tree;
+
+    // type Config = String;
+
+    // fn from_config(config: &Self::Config) -> Result<Self, Error> {
+    //     sled::open(config).map_err(Error::Sled)
+    // }
+
+    fn build_with_change(
+        &self,
+        descriptor: crate::descriptor::ExtendedDescriptor,
+        change_descriptor: Option<crate::descriptor::ExtendedDescriptor>,
+        network: bitcoin::Network,
+        secp: &crate::wallet::utils::SecpCtx,
+    ) -> Result<Self::Inner, Error> {
+        let name = wallet_name_from_descriptor(descriptor, change_descriptor, network, secp)?;
+        self.open_tree(&name).map_err(Error::Sled)
+    }
+}
+
 #[cfg(test)]
 mod test {
     use lazy_static::lazy_static;

src/database/memory.rs

@@ -26,6 +26,8 @@ use crate::database::{BatchDatabase, BatchOperations, ConfigurableDatabase, Data
 use crate::error::Error;
 use crate::types::*;
 
+use super::DatabaseFactory;
+
 // path -> script       p{i,e}<path> -> script
 // script -> path       s<script> -> {i,e}<path>
 // outpoint             u<outpoint> -> txout
@@ -475,6 +477,31 @@ impl ConfigurableDatabase for MemoryDatabase {
     }
 }
 
+/// A [`DatabaseFactory`] implementation that builds [`MemoryDatabase`].
+#[derive(Debug, Default)]
+pub struct MemoryDatabaseFactory;
+
+impl DatabaseFactory for MemoryDatabaseFactory {
+    type Inner = MemoryDatabase;
+    // type Config = ();
+
+    // fn from_config(_: &Self::Config) -> Result<Self, Error> {
+    //     Ok(MemoryDatabaseFactory::default())
+    // }
+
+    fn build_with_change(
+        &self,
+        _descriptor: crate::descriptor::ExtendedDescriptor,
+        _change_descriptor: Option<crate::descriptor::ExtendedDescriptor>,
+        _network: bitcoin::Network,
+        _secp: &crate::wallet::utils::SecpCtx,
+    ) -> Result<Self::Inner, Error> {
+        Ok(MemoryDatabase::default())
+    }
+}
+
+// impl DatabaseFactory for
+
 #[macro_export]
 #[doc(hidden)]
 /// Artificially insert a tx in the database, as if we had found it with a `sync`. This is a hidden

src/database/mod.rs

@@ -27,10 +27,12 @@
 use serde::{Deserialize, Serialize};
 
 use bitcoin::hash_types::Txid;
-use bitcoin::{OutPoint, Script, Transaction, TxOut};
+use bitcoin::{Network, OutPoint, Script, Transaction, TxOut};
 
+use crate::descriptor::ExtendedDescriptor;
 use crate::error::Error;
 use crate::types::*;
+use crate::wallet::utils::SecpCtx;
 
 pub mod any;
 pub use any::{AnyDatabase, AnyDatabaseConfig};
@@ -212,6 +214,31 @@ pub(crate) trait DatabaseUtils: Database {
 
 impl<T: Database> DatabaseUtils for T {}
 
+/// Trait for a factory that build databases, sharing the underlying configurations or storage path.
+pub trait DatabaseFactory: Sized {
+    /// Inner type to build
+    type Inner: Database;
+
+    /// Builds the defined [`DatabaseFactory::Inner`] type.
+    fn build(
+        &self,
+        descriptor: ExtendedDescriptor,
+        network: Network,
+        secp: &SecpCtx,
+    ) -> Result<Self::Inner, Error> {
+        self.build_with_change(descriptor, None, network, secp)
+    }
+
+    /// Builds the defined [`DatabaseFactory::Inner`] type with the addition of a change descriptor.
+    fn build_with_change(
+        &self,
+        descriptor: ExtendedDescriptor,
+        change_descriptor: Option<ExtendedDescriptor>,
+        network: Network,
+        secp: &SecpCtx,
+    ) -> Result<Self::Inner, Error>;
+}
+
 #[cfg(test)]
 pub mod test {
     use std::str::FromStr;

src/database/sqlite.rs

@@ -16,9 +16,12 @@ use bitcoin::{OutPoint, Script, Transaction, TxOut};
 use crate::database::{BatchDatabase, BatchOperations, Database, SyncTime};
 use crate::error::Error;
 use crate::types::*;
+use crate::wallet::wallet_name_from_descriptor;
 
 use rusqlite::{named_params, Connection};
 
+use super::DatabaseFactory;
+
 static MIGRATIONS: &[&str] = &[
     "CREATE TABLE version (version INTEGER)",
     "INSERT INTO version VALUES (1)",
@@ -970,6 +973,43 @@ pub fn migrate(conn: &Connection) -> rusqlite::Result<()> {
     Ok(())
 }
 
+/// A [`DatabaseFactory`] implementation that builds [`SqliteDatabase`].
+///
+/// Each built database is stored in path of format: `<path_root>_<hash>.<path_ext>`
+/// Where `hash` contains identifying data derived with inputs provided by
+/// [`DatabaseFactory::build`] or [`DatabaseFactory::build_with_change`] calls.
+pub struct SqliteDatabaseFactory {
+    pub path_root: String,
+    pub path_ext: String,
+}
+
+impl DatabaseFactory for SqliteDatabaseFactory {
+    type Inner = SqliteDatabase;
+
+    // /// Configuration of format `(path_root, path_ext)`.
+    // type Config = (String, String);
+
+    // fn from_config(config: &Self::Config) -> Result<Self, Error> {
+    //     let (path_root, path_ext) = config.to_owned();
+    //     Ok(Self {
+    //         path_root,
+    //         path_ext,
+    //     })
+    // }
+
+    fn build_with_change(
+        &self,
+        descriptor: crate::descriptor::ExtendedDescriptor,
+        change_descriptor: Option<crate::descriptor::ExtendedDescriptor>,
+        network: bitcoin::Network,
+        secp: &crate::wallet::utils::SecpCtx,
+    ) -> Result<Self::Inner, Error> {
+        let name = wallet_name_from_descriptor(descriptor, change_descriptor, network, secp)?;
+        let path = format!("{}_{}.{}", self.path_root, name, self.path_ext);
+        Ok(Self::Inner::new(path))
+    }
+}
+
 #[cfg(test)]
 pub mod test {
     use crate::database::SqliteDatabase;