[database] Wrap BlockTime in another struct to allow adding more

afilini · afilini · commit 8dfe72f2ee16 · 2021-11-08T10:37:53.000+01:00
fields in the future
diff --git a/src/database/any.rs b/src/database/any.rs
@@ -144,8 +144,8 @@ impl BatchOperations for AnyDatabase {
     fn set_last_index(&mut self, keychain: KeychainKind, value: u32) -> Result<(), Error> {
         impl_inner_method!(AnyDatabase, self, set_last_index, keychain, value)
     }
-    fn set_last_sync_time(&mut self, last_sync_time: BlockTime) -> Result<(), Error> {
-        impl_inner_method!(AnyDatabase, self, set_last_sync_time, last_sync_time)
+    fn set_sync_time(&mut self, sync_time: SyncTime) -> Result<(), Error> {
+        impl_inner_method!(AnyDatabase, self, set_sync_time, sync_time)
     }
 
     fn del_script_pubkey_from_path(
@@ -183,8 +183,8 @@ impl BatchOperations for AnyDatabase {
     fn del_last_index(&mut self, keychain: KeychainKind) -> Result<Option<u32>, Error> {
         impl_inner_method!(AnyDatabase, self, del_last_index, keychain)
     }
-    fn del_last_sync_time(&mut self) -> Result<Option<BlockTime>, Error> {
-        impl_inner_method!(AnyDatabase, self, del_last_sync_time)
+    fn del_sync_time(&mut self) -> Result<Option<SyncTime>, Error> {
+        impl_inner_method!(AnyDatabase, self, del_sync_time)
     }
 }
 
@@ -247,8 +247,8 @@ impl Database for AnyDatabase {
     fn get_last_index(&self, keychain: KeychainKind) -> Result<Option<u32>, Error> {
         impl_inner_method!(AnyDatabase, self, get_last_index, keychain)
     }
-    fn get_last_sync_time(&self) -> Result<Option<BlockTime>, Error> {
-        impl_inner_method!(AnyDatabase, self, get_last_sync_time)
+    fn get_sync_time(&self) -> Result<Option<SyncTime>, Error> {
+        impl_inner_method!(AnyDatabase, self, get_sync_time)
     }
 
     fn increment_last_index(&mut self, keychain: KeychainKind) -> Result<u32, Error> {
@@ -281,8 +281,8 @@ impl BatchOperations for AnyBatch {
     fn set_last_index(&mut self, keychain: KeychainKind, value: u32) -> Result<(), Error> {
         impl_inner_method!(AnyBatch, self, set_last_index, keychain, value)
     }
-    fn set_last_sync_time(&mut self, last_sync_time: BlockTime) -> Result<(), Error> {
-        impl_inner_method!(AnyBatch, self, set_last_sync_time, last_sync_time)
+    fn set_sync_time(&mut self, sync_time: SyncTime) -> Result<(), Error> {
+        impl_inner_method!(AnyBatch, self, set_sync_time, sync_time)
     }
 
     fn del_script_pubkey_from_path(
@@ -314,8 +314,8 @@ impl BatchOperations for AnyBatch {
     fn del_last_index(&mut self, keychain: KeychainKind) -> Result<Option<u32>, Error> {
         impl_inner_method!(AnyBatch, self, del_last_index, keychain)
     }
-    fn del_last_sync_time(&mut self) -> Result<Option<BlockTime>, Error> {
-        impl_inner_method!(AnyBatch, self, del_last_sync_time)
+    fn del_sync_time(&mut self) -> Result<Option<SyncTime>, Error> {
+        impl_inner_method!(AnyBatch, self, del_sync_time)
     }
 }
 
diff --git a/src/database/keyvalue.rs b/src/database/keyvalue.rs
@@ -18,7 +18,7 @@ use bitcoin::hash_types::Txid;
 use bitcoin::{OutPoint, Script, Transaction};
 
 use crate::database::memory::MapKey;
-use crate::database::{BatchDatabase, BatchOperations, Database};
+use crate::database::{BatchDatabase, BatchOperations, Database, SyncTime};
 use crate::error::Error;
 use crate::types::*;
 
@@ -82,9 +82,9 @@ macro_rules! impl_batch_operations {
             Ok(())
         }
 
-        fn set_last_sync_time(&mut self, ct: BlockTime) -> Result<(), Error> {
-            let key = MapKey::LastSyncTime.as_map_key();
-            self.insert(key, serde_json::to_vec(&ct)?)$($after_insert)*;
+        fn set_sync_time(&mut self, data: SyncTime) -> Result<(), Error> {
+            let key = MapKey::SyncTime.as_map_key();
+            self.insert(key, serde_json::to_vec(&data)?)$($after_insert)*;
 
             Ok(())
         }
@@ -176,8 +176,8 @@ macro_rules! impl_batch_operations {
             }
         }
 
-        fn del_last_sync_time(&mut self) -> Result<Option<BlockTime>, Error> {
-            let key = MapKey::LastSyncTime.as_map_key();
+        fn del_sync_time(&mut self) -> Result<Option<SyncTime>, Error> {
+            let key = MapKey::SyncTime.as_map_key();
             let res = self.remove(key);
             let res = $process_delete!(res);
 
@@ -357,8 +357,8 @@ impl Database for Tree {
             .transpose()
     }
 
-    fn get_last_sync_time(&self) -> Result<Option<BlockTime>, Error> {
-        let key = MapKey::LastSyncTime.as_map_key();
+    fn get_sync_time(&self) -> Result<Option<SyncTime>, Error> {
+        let key = MapKey::SyncTime.as_map_key();
         Ok(self
             .get(key)?
             .map(|b| serde_json::from_slice(&b))
@@ -495,7 +495,7 @@ mod test {
     }
 
     #[test]
-    fn test_last_sync_time() {
-        crate::database::test::test_last_sync_time(get_tree());
+    fn test_sync_time() {
+        crate::database::test::test_sync_time(get_tree());
     }
 }
diff --git a/src/database/memory.rs b/src/database/memory.rs
@@ -22,7 +22,7 @@ use bitcoin::consensus::encode::{deserialize, serialize};
 use bitcoin::hash_types::Txid;
 use bitcoin::{OutPoint, Script, Transaction};
 
-use crate::database::{BatchDatabase, BatchOperations, ConfigurableDatabase, Database};
+use crate::database::{BatchDatabase, BatchOperations, ConfigurableDatabase, Database, SyncTime};
 use crate::error::Error;
 use crate::types::*;
 
@@ -42,7 +42,7 @@ pub(crate) enum MapKey<'a> {
     RawTx(Option<&'a Txid>),
     Transaction(Option<&'a Txid>),
     LastIndex(KeychainKind),
-    LastSyncTime,
+    SyncTime,
     DescriptorChecksum(KeychainKind),
 }
 
@@ -61,7 +61,7 @@ impl MapKey<'_> {
             MapKey::RawTx(_) => b"r".to_vec(),
             MapKey::Transaction(_) => b"t".to_vec(),
             MapKey::LastIndex(st) => [b"c", st.as_ref()].concat(),
-            MapKey::LastSyncTime => b"l".to_vec(),
+            MapKey::SyncTime => b"l".to_vec(),
             MapKey::DescriptorChecksum(st) => [b"d", st.as_ref()].concat(),
         }
     }
@@ -183,9 +183,9 @@ impl BatchOperations for MemoryDatabase {
 
         Ok(())
     }
-    fn set_last_sync_time(&mut self, ct: BlockTime) -> Result<(), Error> {
-        let key = MapKey::LastSyncTime.as_map_key();
-        self.map.insert(key, Box::new(ct));
+    fn set_sync_time(&mut self, data: SyncTime) -> Result<(), Error> {
+        let key = MapKey::SyncTime.as_map_key();
+        self.map.insert(key, Box::new(data));
 
         Ok(())
     }
@@ -279,8 +279,8 @@ impl BatchOperations for MemoryDatabase {
             Some(b) => Ok(Some(*b.downcast_ref().unwrap())),
         }
     }
-    fn del_last_sync_time(&mut self) -> Result<Option<BlockTime>, Error> {
-        let key = MapKey::LastSyncTime.as_map_key();
+    fn del_sync_time(&mut self) -> Result<Option<SyncTime>, Error> {
+        let key = MapKey::SyncTime.as_map_key();
         let res = self.map.remove(&key);
         self.deleted_keys.push(key);
 
@@ -423,8 +423,8 @@ impl Database for MemoryDatabase {
         Ok(self.map.get(&key).map(|b| *b.downcast_ref().unwrap()))
     }
 
-    fn get_last_sync_time(&self) -> Result<Option<BlockTime>, Error> {
-        let key = MapKey::LastSyncTime.as_map_key();
+    fn get_sync_time(&self) -> Result<Option<SyncTime>, Error> {
+        let key = MapKey::SyncTime.as_map_key();
         Ok(self
             .map
             .get(&key)
@@ -503,12 +503,10 @@ macro_rules! populate_test_db {
         };
 
         let txid = tx.txid();
-        let confirmation_time = tx_meta
-            .min_confirmations
-            .map(|conf| $crate::BlockTime {
-                height: current_height.unwrap().checked_sub(conf as u32).unwrap(),
-                timestamp: 0,
-            });
+        let confirmation_time = tx_meta.min_confirmations.map(|conf| $crate::BlockTime {
+            height: current_height.unwrap().checked_sub(conf as u32).unwrap(),
+            timestamp: 0,
+        });
 
         let tx_details = $crate::TransactionDetails {
             transaction: Some(tx.clone()),
@@ -616,7 +614,7 @@ mod test {
     }
 
     #[test]
-    fn test_last_sync_time() {
-        crate::database::test::test_last_sync_time(get_tree());
+    fn test_sync_time() {
+        crate::database::test::test_sync_time(get_tree());
     }
 }
diff --git a/src/database/mod.rs b/src/database/mod.rs
@@ -24,6 +24,8 @@
 //!
 //! [`Wallet`]: crate::wallet::Wallet
 
+use serde::{Deserialize, Serialize};
+
 use bitcoin::hash_types::Txid;
 use bitcoin::{OutPoint, Script, Transaction, TxOut};
 
@@ -44,6 +46,15 @@ pub use sqlite::SqliteDatabase;
 pub mod memory;
 pub use memory::MemoryDatabase;
 
+/// Blockchain state at the time of syncing
+///
+/// Contains only the block time and height at the moment
+#[derive(Clone, Debug, Serialize, Deserialize)]
+pub struct SyncTime {
+    /// Block timestamp and height at the time of sync
+    pub block_time: BlockTime,
+}
+
 /// Trait for operations that can be batched
 ///
 /// This trait defines the list of operations that must be implemented on the [`Database`] type and
@@ -64,8 +75,8 @@ pub trait BatchOperations {
     fn set_tx(&mut self, transaction: &TransactionDetails) -> Result<(), Error>;
     /// Store the last derivation index for a given keychain.
     fn set_last_index(&mut self, keychain: KeychainKind, value: u32) -> Result<(), Error>;
-    /// Store the sync time in terms of block height and timestamp
-    fn set_last_sync_time(&mut self, last_sync_time: BlockTime) -> Result<(), Error>;
+    /// Store the sync time
+    fn set_sync_time(&mut self, sync_time: SyncTime) -> Result<(), Error>;
 
     /// Delete a script_pubkey given the keychain and its child number.
     fn del_script_pubkey_from_path(
@@ -91,10 +102,10 @@ pub trait BatchOperations {
     ) -> Result<Option<TransactionDetails>, Error>;
     /// Delete the last derivation index for a keychain.
     fn del_last_index(&mut self, keychain: KeychainKind) -> Result<Option<u32>, Error>;
-    /// Reset the last sync time to `None`
+    /// Reset the sync time to `None`
     ///
     /// Returns the removed value
-    fn del_last_sync_time(&mut self) -> Result<Option<BlockTime>, Error>;
+    fn del_sync_time(&mut self) -> Result<Option<SyncTime>, Error>;
 }
 
 /// Trait for reading data from a database
@@ -140,8 +151,8 @@ pub trait Database: BatchOperations {
     fn get_tx(&self, txid: &Txid, include_raw: bool) -> Result<Option<TransactionDetails>, Error>;
     /// Return the last defivation index for a keychain.
     fn get_last_index(&self, keychain: KeychainKind) -> Result<Option<u32>, Error>;
-    /// Return the last sync time, if present
-    fn get_last_sync_time(&self) -> Result<Option<BlockTime>, Error>;
+    /// Return the sync time, if present
+    fn get_sync_time(&self) -> Result<Option<SyncTime>, Error>;
 
     /// Increment the last derivation index for a keychain and return it
     ///
@@ -385,22 +396,24 @@ pub mod test {
         );
     }
 
-    pub fn test_last_sync_time<D: Database>(mut tree: D) {
-        assert!(tree.get_last_sync_time().unwrap().is_none());
+    pub fn test_sync_time<D: Database>(mut tree: D) {
+        assert!(tree.get_sync_time().unwrap().is_none());
 
-        tree.set_last_sync_time(BlockTime {
-            height: 100,
-            timestamp: 1000,
+        tree.set_sync_time(SyncTime {
+            block_time: BlockTime {
+                height: 100,
+                timestamp: 1000,
+            },
         })
         .unwrap();
 
-        let extracted = tree.get_last_sync_time().unwrap();
+        let extracted = tree.get_sync_time().unwrap();
         assert!(extracted.is_some());
-        assert_eq!(extracted.as_ref().unwrap().height, 100);
-        assert_eq!(extracted.as_ref().unwrap().timestamp, 1000);
+        assert_eq!(extracted.as_ref().unwrap().block_time.height, 100);
+        assert_eq!(extracted.as_ref().unwrap().block_time.timestamp, 1000);
 
-        tree.del_last_sync_time().unwrap();
-        assert!(tree.get_last_sync_time().unwrap().is_none());
+        tree.del_sync_time().unwrap();
+        assert!(tree.get_sync_time().unwrap().is_none());
     }
 
     // TODO: more tests...
diff --git a/src/database/sqlite.rs b/src/database/sqlite.rs
diff --git a/src/wallet/mod.rs b/src/wallet/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -144,8 +144,8 @@ impl BatchOperations for AnyDatabase {`
`144`	`144`	`fn set_last_index(&mut self, keychain: KeychainKind, value: u32) -> Result<(), Error> {`
`145`	`145`	`impl_inner_method!(AnyDatabase, self, set_last_index, keychain, value)`
`146`	`146`	`}`
`147`		`- fn set_last_sync_time(&mut self, last_sync_time: BlockTime) -> Result<(), Error> {`
`148`		`- impl_inner_method!(AnyDatabase, self, set_last_sync_time, last_sync_time)`
	`147`	`+ fn set_sync_time(&mut self, sync_time: SyncTime) -> Result<(), Error> {`
	`148`	`+ impl_inner_method!(AnyDatabase, self, set_sync_time, sync_time)`
`149`	`149`	`}`
`150`	`150`
`151`	`151`	`fn del_script_pubkey_from_path(`
`@@ -183,8 +183,8 @@ impl BatchOperations for AnyDatabase {`
`183`	`183`	`fn del_last_index(&mut self, keychain: KeychainKind) -> Result<Option<u32>, Error> {`
`184`	`184`	`impl_inner_method!(AnyDatabase, self, del_last_index, keychain)`
`185`	`185`	`}`
`186`		`- fn del_last_sync_time(&mut self) -> Result<Option<BlockTime>, Error> {`
`187`		`- impl_inner_method!(AnyDatabase, self, del_last_sync_time)`
	`186`	`+ fn del_sync_time(&mut self) -> Result<Option<SyncTime>, Error> {`
	`187`	`+ impl_inner_method!(AnyDatabase, self, del_sync_time)`
`188`	`188`	`}`
`189`	`189`	`}`
`190`	`190`
`@@ -247,8 +247,8 @@ impl Database for AnyDatabase {`
`247`	`247`	`fn get_last_index(&self, keychain: KeychainKind) -> Result<Option<u32>, Error> {`
`248`	`248`	`impl_inner_method!(AnyDatabase, self, get_last_index, keychain)`
`249`	`249`	`}`
`250`		`- fn get_last_sync_time(&self) -> Result<Option<BlockTime>, Error> {`
`251`		`- impl_inner_method!(AnyDatabase, self, get_last_sync_time)`
	`250`	`+ fn get_sync_time(&self) -> Result<Option<SyncTime>, Error> {`
	`251`	`+ impl_inner_method!(AnyDatabase, self, get_sync_time)`
`252`	`252`	`}`
`253`	`253`
`254`	`254`	`fn increment_last_index(&mut self, keychain: KeychainKind) -> Result<u32, Error> {`
`@@ -281,8 +281,8 @@ impl BatchOperations for AnyBatch {`
`281`	`281`	`fn set_last_index(&mut self, keychain: KeychainKind, value: u32) -> Result<(), Error> {`
`282`	`282`	`impl_inner_method!(AnyBatch, self, set_last_index, keychain, value)`
`283`	`283`	`}`
`284`		`- fn set_last_sync_time(&mut self, last_sync_time: BlockTime) -> Result<(), Error> {`
`285`		`- impl_inner_method!(AnyBatch, self, set_last_sync_time, last_sync_time)`
	`284`	`+ fn set_sync_time(&mut self, sync_time: SyncTime) -> Result<(), Error> {`
	`285`	`+ impl_inner_method!(AnyBatch, self, set_sync_time, sync_time)`
`286`	`286`	`}`
`287`	`287`
`288`	`288`	`fn del_script_pubkey_from_path(`
`@@ -314,8 +314,8 @@ impl BatchOperations for AnyBatch {`
`314`	`314`	`fn del_last_index(&mut self, keychain: KeychainKind) -> Result<Option<u32>, Error> {`
`315`	`315`	`impl_inner_method!(AnyBatch, self, del_last_index, keychain)`
`316`	`316`	`}`
`317`		`- fn del_last_sync_time(&mut self) -> Result<Option<BlockTime>, Error> {`
`318`		`- impl_inner_method!(AnyBatch, self, del_last_sync_time)`
	`317`	`+ fn del_sync_time(&mut self) -> Result<Option<SyncTime>, Error> {`
	`318`	`+ impl_inner_method!(AnyBatch, self, del_sync_time)`
`319`	`319`	`}`
`320`	`320`	`}`
`321`	`321`
Original file line number	Diff line number	Diff line change
`@@ -18,7 +18,7 @@ use bitcoin::hash_types::Txid;`
`18`	`18`	`use bitcoin::{OutPoint, Script, Transaction};`
`19`	`19`
`20`	`20`	`use crate::database::memory::MapKey;`
`21`		`-use crate::database::{BatchDatabase, BatchOperations, Database};`
	`21`	`+use crate::database::{BatchDatabase, BatchOperations, Database, SyncTime};`
`22`	`22`	`use crate::error::Error;`
`23`	`23`	`use crate::types::*;`
`24`	`24`
`@@ -82,9 +82,9 @@ macro_rules! impl_batch_operations {`
`82`	`82`	`Ok(())`
`83`	`83`	`}`
`84`	`84`
`85`		`- fn set_last_sync_time(&mut self, ct: BlockTime) -> Result<(), Error> {`
`86`		`- let key = MapKey::LastSyncTime.as_map_key();`
`87`		`- self.insert(key, serde_json::to_vec(&ct)?)$($after_insert)*;`
	`85`	`+ fn set_sync_time(&mut self, data: SyncTime) -> Result<(), Error> {`
	`86`	`+ let key = MapKey::SyncTime.as_map_key();`
	`87`	`+ self.insert(key, serde_json::to_vec(&data)?)$($after_insert)*;`
`88`	`88`
`89`	`89`	`Ok(())`
`90`	`90`	`}`
`@@ -176,8 +176,8 @@ macro_rules! impl_batch_operations {`
`176`	`176`	`}`
`177`	`177`	`}`
`178`	`178`
`179`		`- fn del_last_sync_time(&mut self) -> Result<Option<BlockTime>, Error> {`
`180`		`- let key = MapKey::LastSyncTime.as_map_key();`
	`179`	`+ fn del_sync_time(&mut self) -> Result<Option<SyncTime>, Error> {`
	`180`	`+ let key = MapKey::SyncTime.as_map_key();`
`181`	`181`	`let res = self.remove(key);`
`182`	`182`	`let res = $process_delete!(res);`
`183`	`183`
`@@ -357,8 +357,8 @@ impl Database for Tree {`
`357`	`357`	`.transpose()`
`358`	`358`	`}`
`359`	`359`
`360`		`- fn get_last_sync_time(&self) -> Result<Option<BlockTime>, Error> {`
`361`		`- let key = MapKey::LastSyncTime.as_map_key();`
	`360`	`+ fn get_sync_time(&self) -> Result<Option<SyncTime>, Error> {`
	`361`	`+ let key = MapKey::SyncTime.as_map_key();`
`362`	`362`	`Ok(self`
`363`	`363`	`.get(key)?`
`364`	`364`	`.map(\|b\| serde_json::from_slice(&b))`
`@@ -495,7 +495,7 @@ mod test {`
`495`	`495`	`}`
`496`	`496`
`497`	`497`	`#[test]`
`498`		`- fn test_last_sync_time() {`
`499`		`- crate::database::test::test_last_sync_time(get_tree());`
	`498`	`+ fn test_sync_time() {`
	`499`	`+ crate::database::test::test_sync_time(get_tree());`
`500`	`500`	`}`
`501`	`501`	`}`