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(
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)
}
}
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> {
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(
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)
}
}
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::*;
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(())
}
}
}
- 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);
.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))
}
#[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());
}
}
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::*;
RawTx(Option<&'a Txid>),
Transaction(Option<&'a Txid>),
LastIndex(KeychainKind),
- LastSyncTime,
+ SyncTime,
DescriptorChecksum(KeychainKind),
}
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(),
}
}
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(())
}
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);
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)
};
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()),
}
#[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());
}
}
//!
//! [`Wallet`]: crate::wallet::Wallet
+use serde::{Deserialize, Serialize};
+
use bitcoin::hash_types::Txid;
use bitcoin::{OutPoint, Script, Transaction, TxOut};
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
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(
) -> 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
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
///
);
}
- 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...
use bitcoin::hash_types::Txid;
use bitcoin::{OutPoint, Script, Transaction, TxOut};
-use crate::database::{BatchDatabase, BatchOperations, Database};
+use crate::database::{BatchDatabase, BatchOperations, Database, SyncTime};
use crate::error::Error;
use crate::types::*;
"CREATE UNIQUE INDEX idx_indices_keychain ON last_derivation_indices(keychain);",
"CREATE TABLE checksums (keychain TEXT, checksum BLOB);",
"CREATE INDEX idx_checksums_keychain ON checksums(keychain);",
- "CREATE TABLE last_sync_time (id INTEGER PRIMARY KEY, height INTEGER, timestamp INTEGER);"
+ "CREATE TABLE sync_time (id INTEGER PRIMARY KEY, height INTEGER, timestamp INTEGER);"
];
/// Sqlite database stored on filesystem
Ok(())
}
- fn update_last_sync_time(&self, ct: BlockTime) -> Result<i64, Error> {
+ fn update_sync_time(&self, data: SyncTime) -> Result<i64, Error> {
let mut statement = self.connection.prepare_cached(
- "INSERT INTO last_sync_time (id, height, timestamp) VALUES (0, :height, :timestamp) ON CONFLICT(id) DO UPDATE SET height=:height, timestamp=:timestamp WHERE id = 0",
+ "INSERT INTO sync_time (id, height, timestamp) VALUES (0, :height, :timestamp) ON CONFLICT(id) DO UPDATE SET height=:height, timestamp=:timestamp WHERE id = 0",
)?;
statement.execute(named_params! {
- ":height": ct.height,
- ":timestamp": ct.timestamp,
+ ":height": data.block_time.height,
+ ":timestamp": data.block_time.timestamp,
})?;
Ok(self.connection.last_insert_rowid())
}
}
- fn select_last_sync_time(&self) -> Result<Option<BlockTime>, Error> {
+ fn select_sync_time(&self) -> Result<Option<SyncTime>, Error> {
let mut statement = self
.connection
- .prepare_cached("SELECT height, timestamp FROM last_sync_time WHERE id = 0")?;
- let mut rows = statement.query_map([], |row| {
- Ok(BlockTime {
- height: row.get(0)?,
- timestamp: row.get(1)?,
- })
- })?;
+ .prepare_cached("SELECT height, timestamp FROM sync_time WHERE id = 0")?;
+ let mut rows = statement.query([])?;
- Ok(rows.next().transpose()?)
+ if let Some(row) = rows.next()? {
+ Ok(Some(SyncTime {
+ block_time: BlockTime {
+ height: row.get(0)?,
+ timestamp: row.get(1)?,
+ },
+ }))
+ } else {
+ Ok(None)
+ }
}
fn select_checksum_by_keychain(&self, keychain: String) -> Result<Option<Vec<u8>>, Error> {
Ok(())
}
- fn delete_last_sync_time(&self) -> Result<(), Error> {
+ fn delete_sync_time(&self) -> Result<(), Error> {
let mut statement = self
.connection
- .prepare_cached("DELETE FROM last_sync_time WHERE id = 0")?;
+ .prepare_cached("DELETE FROM sync_time WHERE id = 0")?;
statement.execute([])?;
Ok(())
}
Ok(())
}
- fn set_last_sync_time(&mut self, ct: BlockTime) -> Result<(), Error> {
- self.update_last_sync_time(ct)?;
+ fn set_sync_time(&mut self, ct: SyncTime) -> Result<(), Error> {
+ self.update_sync_time(ct)?;
Ok(())
}
}
}
- fn del_last_sync_time(&mut self) -> Result<Option<BlockTime>, Error> {
- match self.select_last_sync_time()? {
+ fn del_sync_time(&mut self) -> Result<Option<SyncTime>, Error> {
+ match self.select_sync_time()? {
Some(value) => {
- self.delete_last_sync_time()?;
+ self.delete_sync_time()?;
Ok(Some(value))
}
Ok(value)
}
- fn get_last_sync_time(&self) -> Result<Option<BlockTime>, Error> {
- self.select_last_sync_time()
+ fn get_sync_time(&self) -> Result<Option<SyncTime>, Error> {
+ self.select_sync_time()
}
fn increment_last_index(&mut self, keychain: KeychainKind) -> Result<u32, Error> {
}
#[test]
- fn test_last_sync_time() {
- crate::database::test::test_last_sync_time(get_database());
+ fn test_sync_time() {
+ crate::database::test::test_sync_time(get_database());
}
}
use crate::blockchain::{Blockchain, Progress};
use crate::database::memory::MemoryDatabase;
-use crate::database::{BatchDatabase, BatchOperations, DatabaseUtils};
+use crate::database::{BatchDatabase, BatchOperations, DatabaseUtils, SyncTime};
use crate::descriptor::derived::AsDerived;
use crate::descriptor::policy::BuildSatisfaction;
use crate::descriptor::{
}
}
- let last_sync_time = BlockTime {
- height: maybe_await!(self.client.get_height())?,
- timestamp: time::get_timestamp(),
+ let sync_time = SyncTime {
+ block_time: BlockTime {
+ height: maybe_await!(self.client.get_height())?,
+ timestamp: time::get_timestamp(),
+ },
};
- debug!("Saving `last_sync_time` = {:?}", last_sync_time);
- self.database
- .borrow_mut()
- .set_last_sync_time(last_sync_time)?;
+ debug!("Saving `sync_time` = {:?}", sync_time);
+ self.database.borrow_mut().set_sync_time(sync_time)?;
Ok(())
}
projects / bdk / commitdiff