feat: add functions to persist the wallet

Also modified `simple_keyring.rs` to incorporate the new persistence
functions.

Author: 110CodingP

Cargo.toml

@@ -77,3 +77,4 @@ name = "bitcoind_rpc"
 
 [[example]]
 name = "simple_keyring"
+required-features = ["rusqlite"]

examples/simple_keyring.rs

@@ -1,5 +1,5 @@
 use bdk_wallet::keyring::KeyRing;
-use bdk_wallet::{KeychainKind, Wallet};
+use bdk_wallet::{KeychainKind, LoadParams, Wallet};
 use bitcoin::Network;
 
 static EXTERNAL_DESCRIPTOR: &str = "tr([5bc5d243/86'/1'/0']tpubDC72NVP1RK5qwy2QdEfWphDsUBAfBu7oiV6jEFooHP8tGQGFVUeFxhgZxuk1j6EQRJ1YsS3th2RyDgReRqCL4zqp4jtuV2z7gbiqDH2iyUS/0/*)";
@@ -8,18 +8,33 @@ static INTERNAL_DESCRIPTOR: &str = "tr([5bc5d243/86'/1'/0']tpubDC72NVP1RK5qwy2Qd
 // Simple KeyRing, allowing us to build a standard 2-descriptor wallet with receive and change
 // keychains.
 
+use bdk_chain::rusqlite;
+
 fn main() {
-    let mut keyring: KeyRing<KeychainKind> = KeyRing::new(
-        Network::Regtest,
-        KeychainKind::External,
-        EXTERNAL_DESCRIPTOR,
-    )
-    .unwrap();
-    keyring
-        .add_descriptor(KeychainKind::Internal, INTERNAL_DESCRIPTOR, false)
-        .unwrap();
+    let mut conn = rusqlite::Connection::open(".bdk_example_wallet.sqlite").unwrap();
+    let params = LoadParams::new()
+        .check_default(KeychainKind::External)
+        .check_descriptor(KeychainKind::External, Some(EXTERNAL_DESCRIPTOR))
+        .check_descriptor(KeychainKind::Internal, Some(INTERNAL_DESCRIPTOR))
+        .check_genesis_hash(bitcoin::constants::genesis_block(Network::Regtest).block_hash())
+        .check_network(Network::Regtest);
+    let mut wallet = match Wallet::<KeychainKind>::from_sqlite(&mut conn, params).unwrap() {
+        Some(wallet) => wallet,
+        None => {
+            let mut keyring: KeyRing<KeychainKind> = KeyRing::new(
+                Network::Regtest,
+                KeychainKind::External,
+                EXTERNAL_DESCRIPTOR,
+            )
+            .unwrap();
+            keyring
+                .add_descriptor(KeychainKind::Internal, INTERNAL_DESCRIPTOR, false)
+                .unwrap();
 
-    let mut wallet = Wallet::new(keyring);
+            Wallet::new(keyring)
+        }
+    };
     let address = wallet.reveal_next_address(KeychainKind::External).unwrap();
-    println!("Address at index {}: {}", address.index, address.address)
+    println!("Address at index {}: {}", address.index, address.address);
+    wallet.persist_to_sqlite(&mut conn).unwrap();
 }

src/keyring/changeset.rs

@@ -45,3 +45,139 @@ impl<K: Ord> Merge for ChangeSet<K> {
         self.network.is_none() && self.descriptors.is_empty()
     }
 }
+
+#[cfg(feature = "rusqlite")]
+use chain::{
+    rusqlite::{self, OptionalExtension},
+    Impl,
+};
+
+#[cfg(feature = "rusqlite")]
+use crate::CanBePersisted;
+
+#[cfg(feature = "rusqlite")]
+impl<K> ChangeSet<K>
+where
+    K: Ord + Clone + CanBePersisted,
+{
+    /// Schema name for `KeyRing`
+    pub const SCHEMA_NAME: &str = "bdk_keyring";
+    /// Name of table storing the network
+    pub const NETWORK_TABLE_NAME: &str = "bdk_network";
+    /// Name of table storing the descriptors
+    pub const DESCRIPTORS_TABLE_NAME: &str = "bdk_descriptor";
+
+    /// Returns the v0 sqlite schema for [`ChangeSet`]
+    pub fn schema_v0() -> alloc::string::String {
+        format!(
+            "CREATE TABLE {} ( \
+                id INTEGER PRIMARY KEY NOT NULL, \
+                network TEXT NOT NULL \
+            ) STRICT ; \
+            CREATE TABLE {} ( \
+               keychain TEXT PRIMARY KEY NOT NULL, \
+               descriptor TEXT UNIQUE NOT NULL, \
+               is_default INTEGER NOT NULL CHECK ( is_default IN (0,1) ) \
+            ) STRICT ;",
+            Self::NETWORK_TABLE_NAME,
+            Self::DESCRIPTORS_TABLE_NAME
+        )
+    }
+
+    /// Initialize sqlite tables
+    pub fn init_sqlite_tables(db_tx: &rusqlite::Transaction) -> rusqlite::Result<()> {
+        bdk_chain::rusqlite_impl::migrate_schema(db_tx, Self::SCHEMA_NAME, &[&Self::schema_v0()])?;
+        Ok(())
+    }
+
+    /// Construct the `KeyRing` from persistence
+    ///
+    /// Remember to call [`Self::init_sqlite_tables`] beforehand.
+    pub fn from_sqlite(db_tx: &rusqlite::Transaction) -> rusqlite::Result<Self> {
+        let mut changeset = Self::default();
+        let mut network_stmt = db_tx.prepare(&format!(
+            "SELECT network FROM {} WHERE id = 0",
+            Self::NETWORK_TABLE_NAME,
+        ))?;
+        let row = network_stmt
+            .query_row([], |row| row.get::<_, Impl<bitcoin::Network>>("network"))
+            .optional()?;
+
+        if let Some(Impl(network)) = row {
+            changeset.network = Some(network);
+        }
+
+        let mut descriptor_stmt = db_tx.prepare(&format!(
+            "SELECT keychain, descriptor, is_default FROM {}",
+            Self::DESCRIPTORS_TABLE_NAME
+        ))?;
+
+        let rows = descriptor_stmt.query_map([], |row| {
+            Ok((
+                row.get::<_, K::Persistable>("keychain")?,
+                row.get::<_, Impl<Descriptor<DescriptorPublicKey>>>("descriptor")?,
+                row.get::<_, u8>("is_default")?,
+            ))
+        })?;
+
+        for row in rows {
+            let (keychain_persisted, Impl(descriptor), is_default) = row?;
+            let keychain = K::from_persistable(keychain_persisted);
+            changeset.descriptors.insert(keychain.clone(), descriptor);
+
+            if is_default == 1 {
+                changeset.default_keychain = Some(keychain);
+            }
+        }
+
+        Ok(changeset)
+    }
+
+    /// Persist the `KeyRing`
+    ///
+    /// Remember to call [`Self::init_sqlite_tables`] beforehand.
+    pub fn persist_to_sqlite(&self, db_tx: &rusqlite::Transaction) -> rusqlite::Result<()> {
+        use rusqlite::named_params;
+        let mut network_stmt = db_tx.prepare_cached(&format!(
+            "INSERT OR IGNORE INTO {}(id, network) VALUES(:id, :network)",
+            Self::NETWORK_TABLE_NAME
+        ))?;
+
+        if let Some(network) = self.network {
+            network_stmt.execute(named_params! {
+                ":id": 0,
+                ":network": Impl(network)
+            })?;
+        }
+
+        let mut descriptor_stmt = db_tx.prepare_cached(&format!(
+            "INSERT OR IGNORE INTO {}(keychain, descriptor, is_default) VALUES(:keychain, :desc, :is_default)", Self::DESCRIPTORS_TABLE_NAME
+        ))?;
+
+        for (keychain, desc) in &self.descriptors {
+            descriptor_stmt.execute(named_params! {
+                ":keychain": keychain.clone().to_persistable(),
+                ":desc": Impl(desc.clone()),
+                ":is_default": 0,
+            })?;
+        }
+
+        let mut remove_old_default_stmt = db_tx.prepare_cached(&format!(
+            "UPDATE {} SET is_default = 0 WHERE is_default = 1",
+            Self::DESCRIPTORS_TABLE_NAME,
+        ))?;
+
+        let mut add_default_stmt = db_tx.prepare_cached(&format!(
+            "UPDATE {} SET is_default = 1 WHERE keychain = :keychain",
+            Self::DESCRIPTORS_TABLE_NAME,
+        ))?;
+
+        if let Some(keychain) = &self.default_keychain {
+            remove_old_default_stmt.execute(())?;
+            add_default_stmt
+                .execute(named_params! { ":keychain": keychain.clone().to_persistable(),})?;
+        }
+
+        Ok(())
+    }
+}

src/types.rs

@@ -19,6 +19,12 @@ use bitcoin::{psbt, Weight};
 
 use serde::{Deserialize, Serialize};
 
+#[cfg(feature = "rusqlite")]
+use chain::rusqlite::{
+    self,
+    types::{FromSql, FromSqlResult, ToSql, ToSqlOutput, ValueRef},
+};
+
 /// Types of keychains
 #[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
 pub enum KeychainKind {
@@ -56,6 +62,41 @@ impl AsRef<[u8]> for KeychainKind {
     }
 }
 
+#[cfg(feature = "rusqlite")]
+impl FromSql for KeychainKind {
+    fn column_result(value: ValueRef<'_>) -> FromSqlResult<Self> {
+        Ok(match value.as_str()? {
+            "0" => KeychainKind::External,
+            "1" => KeychainKind::Internal,
+            _ => panic!("KeychainKind cannot be anything other than External(0) and Internal(1)"),
+        })
+    }
+}
+
+#[cfg(feature = "rusqlite")]
+impl ToSql for KeychainKind {
+    fn to_sql(&self) -> rusqlite::Result<ToSqlOutput<'_>> {
+        Ok(match *self {
+            KeychainKind::External => "0".into(),
+            KeychainKind::Internal => "1".into(),
+        })
+    }
+}
+
+#[cfg(feature = "rusqlite")]
+use crate::CanBePersisted;
+
+#[cfg(feature = "rusqlite")]
+impl CanBePersisted for KeychainKind {
+    type Persistable = KeychainKind;
+    fn to_persistable(self) -> KeychainKind {
+        self
+    }
+    fn from_persistable(persisted: KeychainKind) -> KeychainKind {
+        persisted
+    }
+}
+
 /// An unspent output owned by a [`Wallet`].
 ///
 /// [`Wallet`]: crate::Wallet