- BIP39 implementation dependency, in `keys::bip39` changed from tiny-bip39 to rust-bip39.
- Add new method on the `TxBuilder` to embed data in the transaction via `OP_RETURN`. To allow that a fix to check the dust only on spendable output has been introduced.
- Update the `Database` trait to store the last sync timestamp and block height
+- Rename `ConfirmationTime` to `BlockTime`
## [v0.13.0] - [v0.12.0]
use crate::database::{BatchDatabase, BatchOperations, DatabaseUtils};
use crate::error::Error;
use crate::types::{KeychainKind, LocalUtxo, TransactionDetails};
-use crate::{ConfirmationTime, FeeRate};
+use crate::{BlockTime, FeeRate};
use peer::*;
use store::*;
transaction: Some(tx.clone()),
received: incoming,
sent: outgoing,
- confirmation_time: ConfirmationTime::new(height, timestamp),
+ confirmation_time: BlockTime::new(height, timestamp),
verified: height.is_some(),
fee: Some(inputs_sum.saturating_sub(outputs_sum)),
};
use crate::database::{BatchDatabase, DatabaseUtils};
use crate::descriptor::{get_checksum, IntoWalletDescriptor};
use crate::wallet::utils::SecpCtx;
-use crate::{ConfirmationTime, Error, FeeRate, KeychainKind, LocalUtxo, TransactionDetails};
+use crate::{BlockTime, Error, FeeRate, KeychainKind, LocalUtxo, TransactionDetails};
use bitcoincore_rpc::json::{
GetAddressInfoResultLabel, ImportMultiOptions, ImportMultiRequest,
ImportMultiRequestScriptPubkey, ImportMultiRescanSince,
list_txs_ids.insert(txid);
if let Some(mut known_tx) = known_txs.get_mut(&txid) {
let confirmation_time =
- ConfirmationTime::new(tx_result.info.blockheight, tx_result.info.blocktime);
+ BlockTime::new(tx_result.info.blockheight, tx_result.info.blocktime);
if confirmation_time != known_tx.confirmation_time {
// reorg may change tx height
debug!(
let td = TransactionDetails {
transaction: Some(tx),
txid: tx_result.info.txid,
- confirmation_time: ConfirmationTime::new(
+ confirmation_time: BlockTime::new(
tx_result.info.blockheight,
tx_result.info.blocktime,
),
use super::*;
use crate::database::{BatchDatabase, BatchOperations, DatabaseUtils};
use crate::error::Error;
-use crate::types::{ConfirmationTime, KeychainKind, LocalUtxo, TransactionDetails};
+use crate::types::{BlockTime, KeychainKind, LocalUtxo, TransactionDetails};
use crate::wallet::time::Instant;
use crate::wallet::utils::ChunksIterator;
// check if tx height matches, otherwise updates it. timestamp is not in the if clause
// because we are not asking headers for confirmed tx we know about
if tx_details.confirmation_time.as_ref().map(|c| c.height) != height {
- let confirmation_time = ConfirmationTime::new(height, timestamp);
+ let confirmation_time = BlockTime::new(height, timestamp);
let mut new_tx_details = tx_details.clone();
new_tx_details.confirmation_time = confirmation_time;
batch.set_tx(&new_tx_details)?;
transaction: Some(tx),
received: incoming,
sent: outgoing,
- confirmation_time: ConfirmationTime::new(height, timestamp),
+ confirmation_time: BlockTime::new(height, timestamp),
fee: Some(inputs_sum.saturating_sub(outputs_sum)), /* if the tx is a coinbase, fees would be negative */
verified: height.is_some(),
};
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: ConfirmationTime) -> Result<(), Error> {
+ 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 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<ConfirmationTime>, Error> {
+ fn del_last_sync_time(&mut self) -> Result<Option<BlockTime>, Error> {
impl_inner_method!(AnyDatabase, self, del_last_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<ConfirmationTime>, Error> {
+ fn get_last_sync_time(&self) -> Result<Option<BlockTime>, Error> {
impl_inner_method!(AnyDatabase, self, get_last_sync_time)
}
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: ConfirmationTime) -> Result<(), Error> {
+ 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 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<ConfirmationTime>, Error> {
+ fn del_last_sync_time(&mut self) -> Result<Option<BlockTime>, Error> {
impl_inner_method!(AnyBatch, self, del_last_sync_time)
}
}
Ok(())
}
- fn set_last_sync_time(&mut self, ct: ConfirmationTime) -> Result<(), Error> {
+ 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 del_last_sync_time(&mut self) -> Result<Option<ConfirmationTime>, Error> {
+ fn del_last_sync_time(&mut self) -> Result<Option<BlockTime>, Error> {
let key = MapKey::LastSyncTime.as_map_key();
let res = self.remove(key);
let res = $process_delete!(res);
.transpose()
}
- fn get_last_sync_time(&self) -> Result<Option<ConfirmationTime>, Error> {
+ fn get_last_sync_time(&self) -> Result<Option<BlockTime>, Error> {
let key = MapKey::LastSyncTime.as_map_key();
Ok(self
.get(key)?
Ok(())
}
- fn set_last_sync_time(&mut self, ct: ConfirmationTime) -> Result<(), Error> {
+ 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));
Some(b) => Ok(Some(*b.downcast_ref().unwrap())),
}
}
- fn del_last_sync_time(&mut self) -> Result<Option<ConfirmationTime>, Error> {
+ fn del_last_sync_time(&mut self) -> Result<Option<BlockTime>, Error> {
let key = MapKey::LastSyncTime.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<ConfirmationTime>, Error> {
+ fn get_last_sync_time(&self) -> Result<Option<BlockTime>, Error> {
let key = MapKey::LastSyncTime.as_map_key();
Ok(self
.map
let txid = tx.txid();
let confirmation_time = tx_meta
.min_confirmations
- .map(|conf| $crate::ConfirmationTime {
+ .map(|conf| $crate::BlockTime {
height: current_height.unwrap().checked_sub(conf as u32).unwrap(),
timestamp: 0,
});
/// 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: ConfirmationTime) -> Result<(), Error>;
+ fn set_last_sync_time(&mut self, last_sync_time: BlockTime) -> Result<(), Error>;
/// Delete a script_pubkey given the keychain and its child number.
fn del_script_pubkey_from_path(
/// Reset the last sync time to `None`
///
/// Returns the removed value
- fn del_last_sync_time(&mut self) -> Result<Option<ConfirmationTime>, Error>;
+ fn del_last_sync_time(&mut self) -> Result<Option<BlockTime>, Error>;
}
/// Trait for reading data from a database
/// 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<ConfirmationTime>, Error>;
+ fn get_last_sync_time(&self) -> Result<Option<BlockTime>, Error>;
/// Increment the last derivation index for a keychain and return it
///
received: 1337,
sent: 420420,
fee: Some(140),
- confirmation_time: Some(ConfirmationTime {
+ confirmation_time: Some(BlockTime {
timestamp: 123456,
height: 1000,
}),
pub fn test_last_sync_time<D: Database>(mut tree: D) {
assert!(tree.get_last_sync_time().unwrap().is_none());
- tree.set_last_sync_time(ConfirmationTime {
+ tree.set_last_sync_time(BlockTime {
height: 100,
timestamp: 1000,
})
Ok(())
}
- fn update_last_sync_time(&self, ct: ConfirmationTime) -> Result<i64, Error> {
+ fn update_last_sync_time(&self, ct: BlockTime) -> 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",
)?;
};
let confirmation_time = match (height, timestamp) {
- (Some(height), Some(timestamp)) => Some(ConfirmationTime { height, timestamp }),
+ (Some(height), Some(timestamp)) => Some(BlockTime { height, timestamp }),
_ => None,
};
let verified: bool = row.get(6)?;
let confirmation_time = match (height, timestamp) {
- (Some(height), Some(timestamp)) => Some(ConfirmationTime { height, timestamp }),
+ (Some(height), Some(timestamp)) => Some(BlockTime { height, timestamp }),
_ => None,
};
};
let confirmation_time = match (height, timestamp) {
- (Some(height), Some(timestamp)) => Some(ConfirmationTime { height, timestamp }),
+ (Some(height), Some(timestamp)) => Some(BlockTime { height, timestamp }),
_ => None,
};
}
}
- fn select_last_sync_time(&self) -> Result<Option<ConfirmationTime>, Error> {
+ fn select_last_sync_time(&self) -> Result<Option<BlockTime>, 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(ConfirmationTime {
+ Ok(BlockTime {
height: row.get(0)?,
timestamp: row.get(1)?,
})
Ok(())
}
- fn set_last_sync_time(&mut self, ct: ConfirmationTime) -> Result<(), Error> {
+ fn set_last_sync_time(&mut self, ct: BlockTime) -> Result<(), Error> {
self.update_last_sync_time(ct)?;
Ok(())
}
}
}
- fn del_last_sync_time(&mut self) -> Result<Option<ConfirmationTime>, Error> {
+ fn del_last_sync_time(&mut self) -> Result<Option<BlockTime>, Error> {
match self.select_last_sync_time()? {
Some(value) => {
self.delete_last_sync_time()?;
Ok(value)
}
- fn get_last_sync_time(&self) -> Result<Option<ConfirmationTime>, Error> {
+ fn get_last_sync_time(&self) -> Result<Option<BlockTime>, Error> {
self.select_last_sync_time()
}
pub fee: Option<u64>,
/// If the transaction is confirmed, contains height and timestamp of the block containing the
/// transaction, unconfirmed transaction contains `None`.
- pub confirmation_time: Option<ConfirmationTime>,
+ pub confirmation_time: Option<BlockTime>,
/// Whether the tx has been verified against the consensus rules
///
/// Confirmed txs are considered "verified" by default, while unconfirmed txs are checked to
pub verified: bool,
}
-/// Block height and timestamp of the block containing the confirmed transaction
+/// Block height and timestamp of a block
#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Default)]
-pub struct ConfirmationTime {
+pub struct BlockTime {
/// confirmation block height
pub height: u32,
/// confirmation block timestamp
pub timestamp: u64,
}
-impl ConfirmationTime {
- /// Returns `Some` `ConfirmationTime` if both `height` and `timestamp` are `Some`
+/// **DEPRECATED**: Confirmation time of a transaction
+///
+/// The structure has been renamed to `BlockTime`
+#[deprecated(note = "This structure has been renamed to `BlockTime`")]
+pub type ConfirmationTime = BlockTime;
+
+impl BlockTime {
+ /// Returns `Some` `BlockTime` if both `height` and `timestamp` are `Some`
pub fn new(height: Option<u32>, timestamp: Option<u64>) -> Option<Self> {
match (height, timestamp) {
- (Some(height), Some(timestamp)) => Some(ConfirmationTime { height, timestamp }),
+ (Some(height), Some(timestamp)) => Some(BlockTime { height, timestamp }),
_ => None,
}
}
use crate::database::{memory::MemoryDatabase, BatchOperations};
use crate::types::TransactionDetails;
use crate::wallet::Wallet;
- use crate::ConfirmationTime;
+ use crate::BlockTime;
fn get_test_db() -> MemoryDatabase {
let mut db = MemoryDatabase::new();
received: 100_000,
sent: 0,
fee: Some(500),
- confirmation_time: Some(ConfirmationTime {
+ confirmation_time: Some(BlockTime {
timestamp: 12345678,
height: 5000,
}),
}
}
- let last_sync_time = ConfirmationTime {
+ let last_sync_time = BlockTime {
height: maybe_await!(self.client.get_height())?,
timestamp: time::get_timestamp(),
};
let txid = tx.txid();
// skip saving the utxos, we know they can't be used anyways
details.transaction = Some(tx);
- details.confirmation_time = Some(ConfirmationTime {
+ details.confirmation_time = Some(BlockTime {
timestamp: 12345678,
height: 42,
});
projects / bdk / commitdiff