This avoids confusion with the "type of script".
#### Changed
- Rename the library to `bdk`
+- Rename `ScriptType` to `KeychainKind`
- Prettify README examples on github
- Change CI to github actions
- Bump rust-bitcoin to 0.25, fix Cargo dependencies
use bdk::database::MemoryDatabase;
use bdk::descriptor::HDKeyPaths;
use bdk::wallet::address_validator::{AddressValidator, AddressValidatorError};
-use bdk::ScriptType;
+use bdk::KeychainKind;
use bdk::{OfflineWallet, Wallet};
use bitcoin::hashes::hex::FromHex;
impl AddressValidator for DummyValidator {
fn validate(
&self,
- script_type: ScriptType,
+ keychain: KeychainKind,
hd_keypaths: &HDKeyPaths,
script: &Script,
) -> Result<(), AddressValidatorError> {
println!(
"Validating `{:?}` {} address, script: {}",
- script_type, path, script
+ keychain, path, script
);
Ok(())
use miniscript::Descriptor;
use bdk::database::memory::MemoryDatabase;
-use bdk::{OfflineWallet, ScriptType, Wallet};
+use bdk::{KeychainKind, OfflineWallet, Wallet};
fn main() {
env_logger::init_from_env(
info!("... First address: {}", wallet.get_new_address().unwrap());
if matches.is_present("parsed_policy") {
- let spending_policy = wallet.policies(ScriptType::External).unwrap();
+ let spending_policy = wallet.policies(KeychainKind::External).unwrap();
info!(
"... Spending policy:\n{}",
serde_json::to_string_pretty(&spending_policy).unwrap()
use super::{Blockchain, Capability, ConfigurableBlockchain, Progress};
use crate::database::{BatchDatabase, BatchOperations, DatabaseUtils};
use crate::error::Error;
-use crate::types::{ScriptType, TransactionDetails, UTXO};
+use crate::types::{KeychainKind, TransactionDetails, UTXO};
use crate::FeeRate;
use peer::*;
outputs_sum += output.value;
// this output is ours, we have a path to derive it
- if let Some((script_type, child)) =
+ if let Some((keychain, child)) =
database.get_path_from_script_pubkey(&output.script_pubkey)?
{
debug!("{} output #{} is mine, adding utxo", tx.txid(), i);
updates.set_utxo(&UTXO {
outpoint: OutPoint::new(tx.txid(), i as u32),
txout: output.clone(),
- script_type,
+ keychain,
})?;
incoming += output.value;
- if script_type == ScriptType::Internal
+ if keychain == KeychainKind::Internal
&& (internal_max_deriv.is_none() || child > internal_max_deriv.unwrap_or(0))
{
*internal_max_deriv = Some(child);
- } else if script_type == ScriptType::External
+ } else if keychain == KeychainKind::External
&& (external_max_deriv.is_none() || child > external_max_deriv.unwrap_or(0))
{
*external_max_deriv = Some(child);
)?;
}
- let current_ext = database.get_last_index(ScriptType::External)?.unwrap_or(0);
+ let current_ext = database
+ .get_last_index(KeychainKind::External)?
+ .unwrap_or(0);
let first_ext_new = external_max_deriv.map(|x| x + 1).unwrap_or(0);
if first_ext_new > current_ext {
info!("Setting external index to {}", first_ext_new);
- database.set_last_index(ScriptType::External, first_ext_new)?;
+ database.set_last_index(KeychainKind::External, first_ext_new)?;
}
- let current_int = database.get_last_index(ScriptType::Internal)?.unwrap_or(0);
+ let current_int = database
+ .get_last_index(KeychainKind::Internal)?
+ .unwrap_or(0);
let first_int_new = internal_max_deriv.map(|x| x + 1).unwrap_or(0);
if first_int_new > current_int {
info!("Setting internal index to {}", first_int_new);
- database.set_last_index(ScriptType::Internal, first_int_new)?;
+ database.set_last_index(KeychainKind::Internal, first_int_new)?;
}
info!("Dropping blocks until {}", buried_height);
use super::*;
use crate::database::{BatchDatabase, BatchOperations, DatabaseUtils};
use crate::error::Error;
-use crate::types::{ScriptType, TransactionDetails, UTXO};
+use crate::types::{KeychainKind, TransactionDetails, UTXO};
use crate::wallet::time::Instant;
use crate::wallet::utils::ChunksIterator;
let mut txid_height = HashMap::new();
let mut max_indexes = HashMap::new();
- let mut wallet_chains = vec![ScriptType::Internal, ScriptType::External];
+ let mut wallet_chains = vec![KeychainKind::Internal, KeychainKind::External];
// shuffling improve privacy, the server doesn't know my first request is from my internal or external addresses
wallet_chains.shuffle(&mut thread_rng());
// download history of our internal and external script_pubkeys
- for script_type in wallet_chains.iter() {
- let script_iter = db.iter_script_pubkeys(Some(*script_type))?.into_iter();
+ for keychain in wallet_chains.iter() {
+ let script_iter = db.iter_script_pubkeys(Some(*keychain))?.into_iter();
for (i, chunk) in ChunksIterator::new(script_iter, stop_gap).enumerate() {
// TODO if i == last, should create another chunk of addresses in db
.filter_map(|(i, v)| v.first().map(|_| i as u32))
.max();
if let Some(max) = max_index {
- max_indexes.insert(script_type, max + (i * chunk_size) as u32);
+ max_indexes.insert(keychain, max + (i * chunk_size) as u32);
}
let flattened: Vec<ELSGetHistoryRes> = call_result.into_iter().flatten().collect();
- debug!("#{} of {:?} results:{}", i, script_type, flattened.len());
+ debug!("#{} of {:?} results:{}", i, keychain, flattened.len());
if flattened.is_empty() {
// Didn't find anything in the last `stop_gap` script_pubkeys, breaking
break;
// saving max indexes
info!("max indexes are: {:?}", max_indexes);
- for script_type in wallet_chains.iter() {
- if let Some(index) = max_indexes.get(script_type) {
- db.set_last_index(*script_type, *index)?;
+ for keychain in wallet_chains.iter() {
+ if let Some(index) = max_indexes.get(keychain) {
+ db.set_last_index(*keychain, *index)?;
}
}
outputs_sum += output.value;
// this output is ours, we have a path to derive it
- if let Some((script_type, _child)) =
- db.get_path_from_script_pubkey(&output.script_pubkey)?
- {
+ if let Some((keychain, _child)) = db.get_path_from_script_pubkey(&output.script_pubkey)? {
debug!("{} output #{} is mine, adding utxo", txid, i);
updates.set_utxo(&UTXO {
outpoint: OutPoint::new(tx.txid(), i as u32),
txout: output.clone(),
- script_type,
+ keychain,
})?;
incoming += output.value;
use crate::blockchain::log_progress;
use crate::error::Error;
-use crate::types::ScriptType;
+use crate::types::KeychainKind;
use crate::{FeeRate, TxBuilder, Wallet};
/// Wallet global options and sub-command
}
let policies = vec![
- external_policy.map(|p| (p, ScriptType::External)),
- internal_policy.map(|p| (p, ScriptType::Internal)),
+ external_policy.map(|p| (p, KeychainKind::External)),
+ internal_policy.map(|p| (p, KeychainKind::Internal)),
];
- for (policy, script_type) in policies.into_iter().filter_map(|x| x) {
+ for (policy, keychain) in policies.into_iter().filter_map(|x| x) {
let policy = serde_json::from_str::<BTreeMap<String, Vec<usize>>>(&policy)
.map_err(|s| Error::Generic(s.to_string()))?;
- tx_builder = tx_builder.policy_path(policy, script_type);
+ tx_builder = tx_builder.policy_path(policy, keychain);
}
let (psbt, details) = wallet.create_tx(tx_builder)?;
Ok(json!({"psbt": base64::encode(&serialize(&psbt)),"details": details,}))
}
WalletSubCommand::Policies => Ok(json!({
- "external": wallet.policies(ScriptType::External)?,
- "internal": wallet.policies(ScriptType::Internal)?,
+ "external": wallet.policies(KeychainKind::External)?,
+ "internal": wallet.policies(KeychainKind::Internal)?,
})),
WalletSubCommand::PublicDescriptor => Ok(json!({
- "external": wallet.public_descriptor(ScriptType::External)?.map(|d| d.to_string()),
- "internal": wallet.public_descriptor(ScriptType::Internal)?.map(|d| d.to_string()),
+ "external": wallet.public_descriptor(KeychainKind::External)?.map(|d| d.to_string()),
+ "internal": wallet.public_descriptor(KeychainKind::Internal)?.map(|d| d.to_string()),
})),
WalletSubCommand::Sign {
psbt,
fn set_script_pubkey(
&mut self,
script: &Script,
- script_type: ScriptType,
+ keychain: KeychainKind,
child: u32,
) -> Result<(), Error> {
impl_inner_method!(
self,
set_script_pubkey,
script,
- script_type,
+ keychain,
child
)
}
fn set_tx(&mut self, transaction: &TransactionDetails) -> Result<(), Error> {
impl_inner_method!(AnyDatabase, self, set_tx, transaction)
}
- fn set_last_index(&mut self, script_type: ScriptType, value: u32) -> Result<(), Error> {
- impl_inner_method!(AnyDatabase, self, set_last_index, script_type, value)
+ fn set_last_index(&mut self, keychain: KeychainKind, value: u32) -> Result<(), Error> {
+ impl_inner_method!(AnyDatabase, self, set_last_index, keychain, value)
}
fn del_script_pubkey_from_path(
&mut self,
- script_type: ScriptType,
+ keychain: KeychainKind,
child: u32,
) -> Result<Option<Script>, Error> {
impl_inner_method!(
AnyDatabase,
self,
del_script_pubkey_from_path,
- script_type,
+ keychain,
child
)
}
fn del_path_from_script_pubkey(
&mut self,
script: &Script,
- ) -> Result<Option<(ScriptType, u32)>, Error> {
+ ) -> Result<Option<(KeychainKind, u32)>, Error> {
impl_inner_method!(AnyDatabase, self, del_path_from_script_pubkey, script)
}
fn del_utxo(&mut self, outpoint: &OutPoint) -> Result<Option<UTXO>, Error> {
) -> Result<Option<TransactionDetails>, Error> {
impl_inner_method!(AnyDatabase, self, del_tx, txid, include_raw)
}
- fn del_last_index(&mut self, script_type: ScriptType) -> Result<Option<u32>, Error> {
- impl_inner_method!(AnyDatabase, self, del_last_index, script_type)
+ fn del_last_index(&mut self, keychain: KeychainKind) -> Result<Option<u32>, Error> {
+ impl_inner_method!(AnyDatabase, self, del_last_index, keychain)
}
}
impl Database for AnyDatabase {
fn check_descriptor_checksum<B: AsRef<[u8]>>(
&mut self,
- script_type: ScriptType,
+ keychain: KeychainKind,
bytes: B,
) -> Result<(), Error> {
impl_inner_method!(
AnyDatabase,
self,
check_descriptor_checksum,
- script_type,
+ keychain,
bytes
)
}
- fn iter_script_pubkeys(&self, script_type: Option<ScriptType>) -> Result<Vec<Script>, Error> {
- impl_inner_method!(AnyDatabase, self, iter_script_pubkeys, script_type)
+ fn iter_script_pubkeys(&self, keychain: Option<KeychainKind>) -> Result<Vec<Script>, Error> {
+ impl_inner_method!(AnyDatabase, self, iter_script_pubkeys, keychain)
}
fn iter_utxos(&self) -> Result<Vec<UTXO>, Error> {
impl_inner_method!(AnyDatabase, self, iter_utxos)
fn get_script_pubkey_from_path(
&self,
- script_type: ScriptType,
+ keychain: KeychainKind,
child: u32,
) -> Result<Option<Script>, Error> {
impl_inner_method!(
AnyDatabase,
self,
get_script_pubkey_from_path,
- script_type,
+ keychain,
child
)
}
fn get_path_from_script_pubkey(
&self,
script: &Script,
- ) -> Result<Option<(ScriptType, u32)>, Error> {
+ ) -> Result<Option<(KeychainKind, u32)>, Error> {
impl_inner_method!(AnyDatabase, self, get_path_from_script_pubkey, script)
}
fn get_utxo(&self, outpoint: &OutPoint) -> Result<Option<UTXO>, Error> {
fn get_tx(&self, txid: &Txid, include_raw: bool) -> Result<Option<TransactionDetails>, Error> {
impl_inner_method!(AnyDatabase, self, get_tx, txid, include_raw)
}
- fn get_last_index(&self, script_type: ScriptType) -> Result<Option<u32>, Error> {
- impl_inner_method!(AnyDatabase, self, get_last_index, script_type)
+ fn get_last_index(&self, keychain: KeychainKind) -> Result<Option<u32>, Error> {
+ impl_inner_method!(AnyDatabase, self, get_last_index, keychain)
}
- fn increment_last_index(&mut self, script_type: ScriptType) -> Result<u32, Error> {
- impl_inner_method!(AnyDatabase, self, increment_last_index, script_type)
+ fn increment_last_index(&mut self, keychain: KeychainKind) -> Result<u32, Error> {
+ impl_inner_method!(AnyDatabase, self, increment_last_index, keychain)
}
}
fn set_script_pubkey(
&mut self,
script: &Script,
- script_type: ScriptType,
+ keychain: KeychainKind,
child: u32,
) -> Result<(), Error> {
- impl_inner_method!(
- AnyBatch,
- self,
- set_script_pubkey,
- script,
- script_type,
- child
- )
+ impl_inner_method!(AnyBatch, self, set_script_pubkey, script, keychain, child)
}
fn set_utxo(&mut self, utxo: &UTXO) -> Result<(), Error> {
impl_inner_method!(AnyBatch, self, set_utxo, utxo)
fn set_tx(&mut self, transaction: &TransactionDetails) -> Result<(), Error> {
impl_inner_method!(AnyBatch, self, set_tx, transaction)
}
- fn set_last_index(&mut self, script_type: ScriptType, value: u32) -> Result<(), Error> {
- impl_inner_method!(AnyBatch, self, set_last_index, script_type, value)
+ fn set_last_index(&mut self, keychain: KeychainKind, value: u32) -> Result<(), Error> {
+ impl_inner_method!(AnyBatch, self, set_last_index, keychain, value)
}
fn del_script_pubkey_from_path(
&mut self,
- script_type: ScriptType,
+ keychain: KeychainKind,
child: u32,
) -> Result<Option<Script>, Error> {
- impl_inner_method!(
- AnyBatch,
- self,
- del_script_pubkey_from_path,
- script_type,
- child
- )
+ impl_inner_method!(AnyBatch, self, del_script_pubkey_from_path, keychain, child)
}
fn del_path_from_script_pubkey(
&mut self,
script: &Script,
- ) -> Result<Option<(ScriptType, u32)>, Error> {
+ ) -> Result<Option<(KeychainKind, u32)>, Error> {
impl_inner_method!(AnyBatch, self, del_path_from_script_pubkey, script)
}
fn del_utxo(&mut self, outpoint: &OutPoint) -> Result<Option<UTXO>, Error> {
) -> Result<Option<TransactionDetails>, Error> {
impl_inner_method!(AnyBatch, self, del_tx, txid, include_raw)
}
- fn del_last_index(&mut self, script_type: ScriptType) -> Result<Option<u32>, Error> {
- impl_inner_method!(AnyBatch, self, del_last_index, script_type)
+ fn del_last_index(&mut self, keychain: KeychainKind) -> Result<Option<u32>, Error> {
+ impl_inner_method!(AnyBatch, self, del_last_index, keychain)
}
}
macro_rules! impl_batch_operations {
( { $($after_insert:tt)* }, $process_delete:ident ) => {
- fn set_script_pubkey(&mut self, script: &Script, script_type: ScriptType, path: u32) -> Result<(), Error> {
- let key = MapKey::Path((Some(script_type), Some(path))).as_map_key();
+ fn set_script_pubkey(&mut self, script: &Script, keychain: KeychainKind, path: u32) -> Result<(), Error> {
+ let key = MapKey::Path((Some(keychain), Some(path))).as_map_key();
self.insert(key, serialize(script))$($after_insert)*;
let key = MapKey::Script(Some(script)).as_map_key();
let value = json!({
- "t": script_type,
+ "t": keychain,
"p": path,
});
self.insert(key, serde_json::to_vec(&value)?)$($after_insert)*;
let key = MapKey::UTXO(Some(&utxo.outpoint)).as_map_key();
let value = json!({
"t": utxo.txout,
- "i": utxo.script_type,
+ "i": utxo.keychain,
});
self.insert(key, serde_json::to_vec(&value)?)$($after_insert)*;
Ok(())
}
- fn set_last_index(&mut self, script_type: ScriptType, value: u32) -> Result<(), Error> {
- let key = MapKey::LastIndex(script_type).as_map_key();
+ fn set_last_index(&mut self, keychain: KeychainKind, value: u32) -> Result<(), Error> {
+ let key = MapKey::LastIndex(keychain).as_map_key();
self.insert(key, &value.to_be_bytes())$($after_insert)*;
Ok(())
}
- fn del_script_pubkey_from_path(&mut self, script_type: ScriptType, path: u32) -> Result<Option<Script>, Error> {
- let key = MapKey::Path((Some(script_type), Some(path))).as_map_key();
+ fn del_script_pubkey_from_path(&mut self, keychain: KeychainKind, path: u32) -> Result<Option<Script>, Error> {
+ let key = MapKey::Path((Some(keychain), Some(path))).as_map_key();
let res = self.remove(key);
let res = $process_delete!(res);
Ok(res.map_or(Ok(None), |x| Some(deserialize(&x)).transpose())?)
}
- fn del_path_from_script_pubkey(&mut self, script: &Script) -> Result<Option<(ScriptType, u32)>, Error> {
+ fn del_path_from_script_pubkey(&mut self, script: &Script) -> Result<Option<(KeychainKind, u32)>, Error> {
let key = MapKey::Script(Some(script)).as_map_key();
let res = self.remove(key);
let res = $process_delete!(res);
Some(b) => {
let mut val: serde_json::Value = serde_json::from_slice(&b)?;
let txout = serde_json::from_value(val["t"].take())?;
- let script_type = serde_json::from_value(val["i"].take())?;
+ let keychain = serde_json::from_value(val["i"].take())?;
- Ok(Some(UTXO { outpoint: outpoint.clone(), txout, script_type }))
+ Ok(Some(UTXO { outpoint: outpoint.clone(), txout, keychain }))
}
}
}
}
}
- fn del_last_index(&mut self, script_type: ScriptType) -> Result<Option<u32>, Error> {
- let key = MapKey::LastIndex(script_type).as_map_key();
+ fn del_last_index(&mut self, keychain: KeychainKind) -> Result<Option<u32>, Error> {
+ let key = MapKey::LastIndex(keychain).as_map_key();
let res = self.remove(key);
let res = $process_delete!(res);
impl Database for Tree {
fn check_descriptor_checksum<B: AsRef<[u8]>>(
&mut self,
- script_type: ScriptType,
+ keychain: KeychainKind,
bytes: B,
) -> Result<(), Error> {
- let key = MapKey::DescriptorChecksum(script_type).as_map_key();
+ let key = MapKey::DescriptorChecksum(keychain).as_map_key();
let prev = self.get(&key)?.map(|x| x.to_vec());
if let Some(val) = prev {
}
}
- fn iter_script_pubkeys(&self, script_type: Option<ScriptType>) -> Result<Vec<Script>, Error> {
- let key = MapKey::Path((script_type, None)).as_map_key();
+ fn iter_script_pubkeys(&self, keychain: Option<KeychainKind>) -> Result<Vec<Script>, Error> {
+ let key = MapKey::Path((keychain, None)).as_map_key();
self.scan_prefix(key)
.map(|x| -> Result<_, Error> {
let (_, v) = x?;
let mut val: serde_json::Value = serde_json::from_slice(&v)?;
let txout = serde_json::from_value(val["t"].take())?;
- let script_type = serde_json::from_value(val["i"].take())?;
+ let keychain = serde_json::from_value(val["i"].take())?;
Ok(UTXO {
outpoint,
txout,
- script_type,
+ keychain,
})
})
.collect()
fn get_script_pubkey_from_path(
&self,
- script_type: ScriptType,
+ keychain: KeychainKind,
path: u32,
) -> Result<Option<Script>, Error> {
- let key = MapKey::Path((Some(script_type), Some(path))).as_map_key();
+ let key = MapKey::Path((Some(keychain), Some(path))).as_map_key();
Ok(self.get(key)?.map(|b| deserialize(&b)).transpose()?)
}
fn get_path_from_script_pubkey(
&self,
script: &Script,
- ) -> Result<Option<(ScriptType, u32)>, Error> {
+ ) -> Result<Option<(KeychainKind, u32)>, Error> {
let key = MapKey::Script(Some(script)).as_map_key();
self.get(key)?
.map(|b| -> Result<_, Error> {
.map(|b| -> Result<_, Error> {
let mut val: serde_json::Value = serde_json::from_slice(&b)?;
let txout = serde_json::from_value(val["t"].take())?;
- let script_type = serde_json::from_value(val["i"].take())?;
+ let keychain = serde_json::from_value(val["i"].take())?;
Ok(UTXO {
outpoint: *outpoint,
txout,
- script_type,
+ keychain,
})
})
.transpose()
.transpose()
}
- fn get_last_index(&self, script_type: ScriptType) -> Result<Option<u32>, Error> {
- let key = MapKey::LastIndex(script_type).as_map_key();
+ fn get_last_index(&self, keychain: KeychainKind) -> Result<Option<u32>, Error> {
+ let key = MapKey::LastIndex(keychain).as_map_key();
self.get(key)?
.map(|b| -> Result<_, Error> {
let array: [u8; 4] = b
}
// inserts 0 if not present
- fn increment_last_index(&mut self, script_type: ScriptType) -> Result<u32, Error> {
- let key = MapKey::LastIndex(script_type).as_map_key();
+ fn increment_last_index(&mut self, keychain: KeychainKind) -> Result<u32, Error> {
+ let key = MapKey::LastIndex(keychain).as_map_key();
self.update_and_fetch(key, |prev| {
let new = match prev {
Some(b) => {
// descriptor checksum d{i,e} -> vec<u8>
pub(crate) enum MapKey<'a> {
- Path((Option<ScriptType>, Option<u32>)),
+ Path((Option<KeychainKind>, Option<u32>)),
Script(Option<&'a Script>),
UTXO(Option<&'a OutPoint>),
RawTx(Option<&'a Txid>),
Transaction(Option<&'a Txid>),
- LastIndex(ScriptType),
- DescriptorChecksum(ScriptType),
+ LastIndex(KeychainKind),
+ DescriptorChecksum(KeychainKind),
}
impl MapKey<'_> {
fn set_script_pubkey(
&mut self,
script: &Script,
- script_type: ScriptType,
+ keychain: KeychainKind,
path: u32,
) -> Result<(), Error> {
- let key = MapKey::Path((Some(script_type), Some(path))).as_map_key();
+ let key = MapKey::Path((Some(keychain), Some(path))).as_map_key();
self.map.insert(key, Box::new(script.clone()));
let key = MapKey::Script(Some(script)).as_map_key();
let value = json!({
- "t": script_type,
+ "t": keychain,
"p": path,
});
self.map.insert(key, Box::new(value));
fn set_utxo(&mut self, utxo: &UTXO) -> Result<(), Error> {
let key = MapKey::UTXO(Some(&utxo.outpoint)).as_map_key();
self.map
- .insert(key, Box::new((utxo.txout.clone(), utxo.script_type)));
+ .insert(key, Box::new((utxo.txout.clone(), utxo.keychain)));
Ok(())
}
Ok(())
}
- fn set_last_index(&mut self, script_type: ScriptType, value: u32) -> Result<(), Error> {
- let key = MapKey::LastIndex(script_type).as_map_key();
+ fn set_last_index(&mut self, keychain: KeychainKind, value: u32) -> Result<(), Error> {
+ let key = MapKey::LastIndex(keychain).as_map_key();
self.map.insert(key, Box::new(value));
Ok(())
fn del_script_pubkey_from_path(
&mut self,
- script_type: ScriptType,
+ keychain: KeychainKind,
path: u32,
) -> Result<Option<Script>, Error> {
- let key = MapKey::Path((Some(script_type), Some(path))).as_map_key();
+ let key = MapKey::Path((Some(keychain), Some(path))).as_map_key();
let res = self.map.remove(&key);
self.deleted_keys.push(key);
fn del_path_from_script_pubkey(
&mut self,
script: &Script,
- ) -> Result<Option<(ScriptType, u32)>, Error> {
+ ) -> Result<Option<(KeychainKind, u32)>, Error> {
let key = MapKey::Script(Some(script)).as_map_key();
let res = self.map.remove(&key);
self.deleted_keys.push(key);
match res {
None => Ok(None),
Some(b) => {
- let (txout, script_type) = b.downcast_ref().cloned().unwrap();
+ let (txout, keychain) = b.downcast_ref().cloned().unwrap();
Ok(Some(UTXO {
outpoint: *outpoint,
txout,
- script_type,
+ keychain,
}))
}
}
}
}
}
- fn del_last_index(&mut self, script_type: ScriptType) -> Result<Option<u32>, Error> {
- let key = MapKey::LastIndex(script_type).as_map_key();
+ fn del_last_index(&mut self, keychain: KeychainKind) -> Result<Option<u32>, Error> {
+ let key = MapKey::LastIndex(keychain).as_map_key();
let res = self.map.remove(&key);
self.deleted_keys.push(key);
impl Database for MemoryDatabase {
fn check_descriptor_checksum<B: AsRef<[u8]>>(
&mut self,
- script_type: ScriptType,
+ keychain: KeychainKind,
bytes: B,
) -> Result<(), Error> {
- let key = MapKey::DescriptorChecksum(script_type).as_map_key();
+ let key = MapKey::DescriptorChecksum(keychain).as_map_key();
let prev = self
.map
}
}
- fn iter_script_pubkeys(&self, script_type: Option<ScriptType>) -> Result<Vec<Script>, Error> {
- let key = MapKey::Path((script_type, None)).as_map_key();
+ fn iter_script_pubkeys(&self, keychain: Option<KeychainKind>) -> Result<Vec<Script>, Error> {
+ let key = MapKey::Path((keychain, None)).as_map_key();
self.map
.range::<Vec<u8>, _>((Included(&key), Excluded(&after(&key))))
.map(|(_, v)| Ok(v.downcast_ref().cloned().unwrap()))
.range::<Vec<u8>, _>((Included(&key), Excluded(&after(&key))))
.map(|(k, v)| {
let outpoint = deserialize(&k[1..]).unwrap();
- let (txout, script_type) = v.downcast_ref().cloned().unwrap();
+ let (txout, keychain) = v.downcast_ref().cloned().unwrap();
Ok(UTXO {
outpoint,
txout,
- script_type,
+ keychain,
})
})
.collect()
fn get_script_pubkey_from_path(
&self,
- script_type: ScriptType,
+ keychain: KeychainKind,
path: u32,
) -> Result<Option<Script>, Error> {
- let key = MapKey::Path((Some(script_type), Some(path))).as_map_key();
+ let key = MapKey::Path((Some(keychain), Some(path))).as_map_key();
Ok(self
.map
.get(&key)
fn get_path_from_script_pubkey(
&self,
script: &Script,
- ) -> Result<Option<(ScriptType, u32)>, Error> {
+ ) -> Result<Option<(KeychainKind, u32)>, Error> {
let key = MapKey::Script(Some(script)).as_map_key();
Ok(self.map.get(&key).map(|b| {
let mut val: serde_json::Value = b.downcast_ref().cloned().unwrap();
fn get_utxo(&self, outpoint: &OutPoint) -> Result<Option<UTXO>, Error> {
let key = MapKey::UTXO(Some(outpoint)).as_map_key();
Ok(self.map.get(&key).map(|b| {
- let (txout, script_type) = b.downcast_ref().cloned().unwrap();
+ let (txout, keychain) = b.downcast_ref().cloned().unwrap();
UTXO {
outpoint: *outpoint,
txout,
- script_type,
+ keychain,
}
}))
}
}))
}
- fn get_last_index(&self, script_type: ScriptType) -> Result<Option<u32>, Error> {
- let key = MapKey::LastIndex(script_type).as_map_key();
+ fn get_last_index(&self, keychain: KeychainKind) -> Result<Option<u32>, Error> {
+ let key = MapKey::LastIndex(keychain).as_map_key();
Ok(self.map.get(&key).map(|b| *b.downcast_ref().unwrap()))
}
// inserts 0 if not present
- fn increment_last_index(&mut self, script_type: ScriptType) -> Result<u32, Error> {
- let key = MapKey::LastIndex(script_type).as_map_key();
+ fn increment_last_index(&mut self, keychain: KeychainKind) -> Result<u32, Error> {
+ let key = MapKey::LastIndex(keychain).as_map_key();
let value = self
.map
.entry(key)
txid,
vout: vout as u32,
},
- script_type: ScriptType::External,
+ keychain: KeychainKind::External,
})
.unwrap();
}
fn set_script_pubkey(
&mut self,
script: &Script,
- script_type: ScriptType,
+ keychain: KeychainKind,
child: u32,
) -> Result<(), Error>;
/// Store a [`UTXO`]
/// Store the metadata of a transaction
fn set_tx(&mut self, transaction: &TransactionDetails) -> Result<(), Error>;
/// Store the last derivation index for a given script type
- fn set_last_index(&mut self, script_type: ScriptType, value: u32) -> Result<(), Error>;
+ fn set_last_index(&mut self, keychain: KeychainKind, value: u32) -> Result<(), Error>;
/// Delete a script_pubkey given the script type and its child number
fn del_script_pubkey_from_path(
&mut self,
- script_type: ScriptType,
+ keychain: KeychainKind,
child: u32,
) -> Result<Option<Script>, Error>;
/// Delete the data related to a specific script_pubkey, meaning the script type and the child
fn del_path_from_script_pubkey(
&mut self,
script: &Script,
- ) -> Result<Option<(ScriptType, u32)>, Error>;
+ ) -> Result<Option<(KeychainKind, u32)>, Error>;
/// Delete a [`UTXO`] given its [`OutPoint`]
fn del_utxo(&mut self, outpoint: &OutPoint) -> Result<Option<UTXO>, Error>;
/// Delete a raw transaction given its [`Txid`]
include_raw: bool,
) -> Result<Option<TransactionDetails>, Error>;
/// Delete the last derivation index for a script type
- fn del_last_index(&mut self, script_type: ScriptType) -> Result<Option<u32>, Error>;
+ fn del_last_index(&mut self, keychain: KeychainKind) -> Result<Option<u32>, Error>;
}
/// Trait for reading data from a database
/// next time.
fn check_descriptor_checksum<B: AsRef<[u8]>>(
&mut self,
- script_type: ScriptType,
+ keychain: KeychainKind,
bytes: B,
) -> Result<(), Error>;
/// Return the list of script_pubkeys
- fn iter_script_pubkeys(&self, script_type: Option<ScriptType>) -> Result<Vec<Script>, Error>;
+ fn iter_script_pubkeys(&self, keychain: Option<KeychainKind>) -> Result<Vec<Script>, Error>;
/// Return the list of [`UTXO`]s
fn iter_utxos(&self) -> Result<Vec<UTXO>, Error>;
/// Return the list of raw transactions
/// Fetch a script_pubkey given the script type and child number
fn get_script_pubkey_from_path(
&self,
- script_type: ScriptType,
+ keychain: KeychainKind,
child: u32,
) -> Result<Option<Script>, Error>;
/// Fetch the script type and child number of a given script_pubkey
fn get_path_from_script_pubkey(
&self,
script: &Script,
- ) -> Result<Option<(ScriptType, u32)>, Error>;
+ ) -> Result<Option<(KeychainKind, u32)>, Error>;
/// Fetch a [`UTXO`] given its [`OutPoint`]
fn get_utxo(&self, outpoint: &OutPoint) -> Result<Option<UTXO>, Error>;
/// Fetch a raw transaction given its [`Txid`]
/// Fetch the transaction metadata and optionally also the raw transaction
fn get_tx(&self, txid: &Txid, include_raw: bool) -> Result<Option<TransactionDetails>, Error>;
/// Return the last defivation index for a script type
- fn get_last_index(&self, script_type: ScriptType) -> Result<Option<u32>, Error>;
+ fn get_last_index(&self, keychain: KeychainKind) -> Result<Option<u32>, Error>;
/// Increment the last derivation index for a script type and returns it
///
/// It should insert and return `0` if not present in the database
- fn increment_last_index(&mut self, script_type: ScriptType) -> Result<u32, Error>;
+ fn increment_last_index(&mut self, keychain: KeychainKind) -> Result<u32, Error>;
}
/// Trait for a database that supports batch operations
Vec::<u8>::from_hex("76a91402306a7c23f3e8010de41e9e591348bb83f11daa88ac").unwrap(),
);
let path = 42;
- let script_type = ScriptType::External;
+ let keychain = KeychainKind::External;
- tree.set_script_pubkey(&script, script_type, path).unwrap();
+ tree.set_script_pubkey(&script, keychain, path).unwrap();
assert_eq!(
- tree.get_script_pubkey_from_path(script_type, path).unwrap(),
+ tree.get_script_pubkey_from_path(keychain, path).unwrap(),
Some(script.clone())
);
assert_eq!(
tree.get_path_from_script_pubkey(&script).unwrap(),
- Some((script_type, path.clone()))
+ Some((keychain, path.clone()))
);
}
Vec::<u8>::from_hex("76a91402306a7c23f3e8010de41e9e591348bb83f11daa88ac").unwrap(),
);
let path = 42;
- let script_type = ScriptType::External;
+ let keychain = KeychainKind::External;
- batch.set_script_pubkey(&script, script_type, path).unwrap();
+ batch.set_script_pubkey(&script, keychain, path).unwrap();
assert_eq!(
- tree.get_script_pubkey_from_path(script_type, path).unwrap(),
+ tree.get_script_pubkey_from_path(keychain, path).unwrap(),
None
);
assert_eq!(tree.get_path_from_script_pubkey(&script).unwrap(), None);
tree.commit_batch(batch).unwrap();
assert_eq!(
- tree.get_script_pubkey_from_path(script_type, path).unwrap(),
+ tree.get_script_pubkey_from_path(keychain, path).unwrap(),
Some(script.clone())
);
assert_eq!(
tree.get_path_from_script_pubkey(&script).unwrap(),
- Some((script_type, path.clone()))
+ Some((keychain, path.clone()))
);
}
Vec::<u8>::from_hex("76a91402306a7c23f3e8010de41e9e591348bb83f11daa88ac").unwrap(),
);
let path = 42;
- let script_type = ScriptType::External;
+ let keychain = KeychainKind::External;
- tree.set_script_pubkey(&script, script_type, path).unwrap();
+ tree.set_script_pubkey(&script, keychain, path).unwrap();
assert_eq!(tree.iter_script_pubkeys(None).unwrap().len(), 1);
}
Vec::<u8>::from_hex("76a91402306a7c23f3e8010de41e9e591348bb83f11daa88ac").unwrap(),
);
let path = 42;
- let script_type = ScriptType::External;
+ let keychain = KeychainKind::External;
- tree.set_script_pubkey(&script, script_type, path).unwrap();
+ tree.set_script_pubkey(&script, keychain, path).unwrap();
assert_eq!(tree.iter_script_pubkeys(None).unwrap().len(), 1);
- tree.del_script_pubkey_from_path(script_type, path).unwrap();
+ tree.del_script_pubkey_from_path(keychain, path).unwrap();
assert_eq!(tree.iter_script_pubkeys(None).unwrap().len(), 0);
}
let utxo = UTXO {
txout,
outpoint,
- script_type: ScriptType::External,
+ keychain: KeychainKind::External,
};
tree.set_utxo(&utxo).unwrap();
}
pub fn test_last_index<D: Database>(mut tree: D) {
- tree.set_last_index(ScriptType::External, 1337).unwrap();
+ tree.set_last_index(KeychainKind::External, 1337).unwrap();
assert_eq!(
- tree.get_last_index(ScriptType::External).unwrap(),
+ tree.get_last_index(KeychainKind::External).unwrap(),
Some(1337)
);
- assert_eq!(tree.get_last_index(ScriptType::Internal).unwrap(), None);
+ assert_eq!(tree.get_last_index(KeychainKind::Internal).unwrap(), None);
- let res = tree.increment_last_index(ScriptType::External).unwrap();
+ let res = tree.increment_last_index(KeychainKind::External).unwrap();
assert_eq!(res, 1338);
- let res = tree.increment_last_index(ScriptType::Internal).unwrap();
+ let res = tree.increment_last_index(KeychainKind::Internal).unwrap();
assert_eq!(res, 0);
assert_eq!(
- tree.get_last_index(ScriptType::External).unwrap(),
+ tree.get_last_index(KeychainKind::External).unwrap(),
Some(1338)
);
- assert_eq!(tree.get_last_index(ScriptType::Internal).unwrap(), Some(0));
+ assert_eq!(
+ tree.get_last_index(KeychainKind::Internal).unwrap(),
+ Some(0)
+ );
}
// TODO: more tests...
use super::{ExtendedDescriptor, KeyMap, ToWalletDescriptor};
use crate::keys::{DerivableKey, KeyError, ToDescriptorKey, ValidNetworks};
-use crate::{descriptor, ScriptType};
+use crate::{descriptor, KeychainKind};
/// Type alias for the return type of [`DescriptorTemplate`], [`descriptor!`](crate::descriptor!) and others
pub type DescriptorTemplateOut = (ExtendedDescriptor, KeyMap, ValidNetworks);
/// ```
/// # use std::str::FromStr;
/// # use bdk::bitcoin::{PrivateKey, Network};
-/// # use bdk::{Wallet, OfflineWallet, ScriptType};
+/// # use bdk::{Wallet, OfflineWallet, KeychainKind};
/// # use bdk::database::MemoryDatabase;
/// use bdk::template::BIP44;
///
/// let key = bitcoin::util::bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPeZRHk4rTG6orPS2CRNFX3njhUXx5vj9qGog5ZMH4uGReDWN5kCkY3jmWEtWause41CDvBRXD1shKknAMKxT99o9qUTRVC6m")?;
/// let wallet: OfflineWallet<_> = Wallet::new_offline(
-/// BIP44(key.clone(), ScriptType::External),
-/// Some(BIP44(key, ScriptType::Internal)),
+/// BIP44(key.clone(), KeychainKind::External),
+/// Some(BIP44(key, KeychainKind::Internal)),
/// Network::Testnet,
/// MemoryDatabase::default()
/// )?;
///
/// assert_eq!(wallet.get_new_address()?.to_string(), "miNG7dJTzJqNbFS19svRdTCisC65dsubtR");
-/// assert_eq!(wallet.public_descriptor(ScriptType::External)?.unwrap().to_string(), "pkh([c55b303f/44'/0'/0']tpubDDDzQ31JkZB7VxUr9bjvBivDdqoFLrDPyLWtLapArAi51ftfmCb2DPxwLQzX65iNcXz1DGaVvyvo6JQ6rTU73r2gqdEo8uov9QKRb7nKCSU/0/*)");
+/// assert_eq!(wallet.public_descriptor(KeychainKind::External)?.unwrap().to_string(), "pkh([c55b303f/44'/0'/0']tpubDDDzQ31JkZB7VxUr9bjvBivDdqoFLrDPyLWtLapArAi51ftfmCb2DPxwLQzX65iNcXz1DGaVvyvo6JQ6rTU73r2gqdEo8uov9QKRb7nKCSU/0/*)");
/// # Ok::<_, Box<dyn std::error::Error>>(())
/// ```
-pub struct BIP44<K: DerivableKey<Legacy>>(pub K, pub ScriptType);
+pub struct BIP44<K: DerivableKey<Legacy>>(pub K, pub KeychainKind);
impl<K: DerivableKey<Legacy>> DescriptorTemplate for BIP44<K> {
fn build(self) -> Result<DescriptorTemplateOut, KeyError> {
/// ```
/// # use std::str::FromStr;
/// # use bdk::bitcoin::{PrivateKey, Network};
-/// # use bdk::{Wallet, OfflineWallet, ScriptType};
+/// # use bdk::{Wallet, OfflineWallet, KeychainKind};
/// # use bdk::database::MemoryDatabase;
/// use bdk::template::BIP44Public;
///
/// let key = bitcoin::util::bip32::ExtendedPubKey::from_str("tpubDDDzQ31JkZB7VxUr9bjvBivDdqoFLrDPyLWtLapArAi51ftfmCb2DPxwLQzX65iNcXz1DGaVvyvo6JQ6rTU73r2gqdEo8uov9QKRb7nKCSU")?;
/// let fingerprint = bitcoin::util::bip32::Fingerprint::from_str("c55b303f")?;
/// let wallet: OfflineWallet<_> = Wallet::new_offline(
-/// BIP44Public(key.clone(), fingerprint, ScriptType::External),
-/// Some(BIP44Public(key, fingerprint, ScriptType::Internal)),
+/// BIP44Public(key.clone(), fingerprint, KeychainKind::External),
+/// Some(BIP44Public(key, fingerprint, KeychainKind::Internal)),
/// Network::Testnet,
/// MemoryDatabase::default()
/// )?;
///
/// assert_eq!(wallet.get_new_address()?.to_string(), "miNG7dJTzJqNbFS19svRdTCisC65dsubtR");
-/// assert_eq!(wallet.public_descriptor(ScriptType::External)?.unwrap().to_string(), "pkh([c55b303f/44'/0'/0']tpubDDDzQ31JkZB7VxUr9bjvBivDdqoFLrDPyLWtLapArAi51ftfmCb2DPxwLQzX65iNcXz1DGaVvyvo6JQ6rTU73r2gqdEo8uov9QKRb7nKCSU/0/*)");
+/// assert_eq!(wallet.public_descriptor(KeychainKind::External)?.unwrap().to_string(), "pkh([c55b303f/44'/0'/0']tpubDDDzQ31JkZB7VxUr9bjvBivDdqoFLrDPyLWtLapArAi51ftfmCb2DPxwLQzX65iNcXz1DGaVvyvo6JQ6rTU73r2gqdEo8uov9QKRb7nKCSU/0/*)");
/// # Ok::<_, Box<dyn std::error::Error>>(())
/// ```
-pub struct BIP44Public<K: DerivableKey<Legacy>>(pub K, pub bip32::Fingerprint, pub ScriptType);
+pub struct BIP44Public<K: DerivableKey<Legacy>>(pub K, pub bip32::Fingerprint, pub KeychainKind);
impl<K: DerivableKey<Legacy>> DescriptorTemplate for BIP44Public<K> {
fn build(self) -> Result<DescriptorTemplateOut, KeyError> {
/// ```
/// # use std::str::FromStr;
/// # use bdk::bitcoin::{PrivateKey, Network};
-/// # use bdk::{Wallet, OfflineWallet, ScriptType};
+/// # use bdk::{Wallet, OfflineWallet, KeychainKind};
/// # use bdk::database::MemoryDatabase;
/// use bdk::template::BIP49;
///
/// let key = bitcoin::util::bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPeZRHk4rTG6orPS2CRNFX3njhUXx5vj9qGog5ZMH4uGReDWN5kCkY3jmWEtWause41CDvBRXD1shKknAMKxT99o9qUTRVC6m")?;
/// let wallet: OfflineWallet<_> = Wallet::new_offline(
-/// BIP49(key.clone(), ScriptType::External),
-/// Some(BIP49(key, ScriptType::Internal)),
+/// BIP49(key.clone(), KeychainKind::External),
+/// Some(BIP49(key, KeychainKind::Internal)),
/// Network::Testnet,
/// MemoryDatabase::default()
/// )?;
///
/// assert_eq!(wallet.get_new_address()?.to_string(), "2N3K4xbVAHoiTQSwxkZjWDfKoNC27pLkYnt");
-/// assert_eq!(wallet.public_descriptor(ScriptType::External)?.unwrap().to_string(), "sh(wpkh([c55b303f/49\'/0\'/0\']tpubDC49r947KGK52X5rBWS4BLs5m9SRY3pYHnvRrm7HcybZ3BfdEsGFyzCMzayi1u58eT82ZeyFZwH7DD6Q83E3fM9CpfMtmnTygnLfP59jL9L/0/*))");
+/// assert_eq!(wallet.public_descriptor(KeychainKind::External)?.unwrap().to_string(), "sh(wpkh([c55b303f/49\'/0\'/0\']tpubDC49r947KGK52X5rBWS4BLs5m9SRY3pYHnvRrm7HcybZ3BfdEsGFyzCMzayi1u58eT82ZeyFZwH7DD6Q83E3fM9CpfMtmnTygnLfP59jL9L/0/*))");
/// # Ok::<_, Box<dyn std::error::Error>>(())
/// ```
-pub struct BIP49<K: DerivableKey<Segwitv0>>(pub K, pub ScriptType);
+pub struct BIP49<K: DerivableKey<Segwitv0>>(pub K, pub KeychainKind);
impl<K: DerivableKey<Segwitv0>> DescriptorTemplate for BIP49<K> {
fn build(self) -> Result<DescriptorTemplateOut, KeyError> {
/// ```
/// # use std::str::FromStr;
/// # use bdk::bitcoin::{PrivateKey, Network};
-/// # use bdk::{Wallet, OfflineWallet, ScriptType};
+/// # use bdk::{Wallet, OfflineWallet, KeychainKind};
/// # use bdk::database::MemoryDatabase;
/// use bdk::template::BIP49Public;
///
/// let key = bitcoin::util::bip32::ExtendedPubKey::from_str("tpubDC49r947KGK52X5rBWS4BLs5m9SRY3pYHnvRrm7HcybZ3BfdEsGFyzCMzayi1u58eT82ZeyFZwH7DD6Q83E3fM9CpfMtmnTygnLfP59jL9L")?;
/// let fingerprint = bitcoin::util::bip32::Fingerprint::from_str("c55b303f")?;
/// let wallet: OfflineWallet<_> = Wallet::new_offline(
-/// BIP49Public(key.clone(), fingerprint, ScriptType::External),
-/// Some(BIP49Public(key, fingerprint, ScriptType::Internal)),
+/// BIP49Public(key.clone(), fingerprint, KeychainKind::External),
+/// Some(BIP49Public(key, fingerprint, KeychainKind::Internal)),
/// Network::Testnet,
/// MemoryDatabase::default()
/// )?;
///
/// assert_eq!(wallet.get_new_address()?.to_string(), "2N3K4xbVAHoiTQSwxkZjWDfKoNC27pLkYnt");
-/// assert_eq!(wallet.public_descriptor(ScriptType::External)?.unwrap().to_string(), "sh(wpkh([c55b303f/49\'/0\'/0\']tpubDC49r947KGK52X5rBWS4BLs5m9SRY3pYHnvRrm7HcybZ3BfdEsGFyzCMzayi1u58eT82ZeyFZwH7DD6Q83E3fM9CpfMtmnTygnLfP59jL9L/0/*))");
+/// assert_eq!(wallet.public_descriptor(KeychainKind::External)?.unwrap().to_string(), "sh(wpkh([c55b303f/49\'/0\'/0\']tpubDC49r947KGK52X5rBWS4BLs5m9SRY3pYHnvRrm7HcybZ3BfdEsGFyzCMzayi1u58eT82ZeyFZwH7DD6Q83E3fM9CpfMtmnTygnLfP59jL9L/0/*))");
/// # Ok::<_, Box<dyn std::error::Error>>(())
/// ```
-pub struct BIP49Public<K: DerivableKey<Segwitv0>>(pub K, pub bip32::Fingerprint, pub ScriptType);
+pub struct BIP49Public<K: DerivableKey<Segwitv0>>(pub K, pub bip32::Fingerprint, pub KeychainKind);
impl<K: DerivableKey<Segwitv0>> DescriptorTemplate for BIP49Public<K> {
fn build(self) -> Result<DescriptorTemplateOut, KeyError> {
/// ```
/// # use std::str::FromStr;
/// # use bdk::bitcoin::{PrivateKey, Network};
-/// # use bdk::{Wallet, OfflineWallet, ScriptType};
+/// # use bdk::{Wallet, OfflineWallet, KeychainKind};
/// # use bdk::database::MemoryDatabase;
/// use bdk::template::BIP84;
///
/// let key = bitcoin::util::bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPeZRHk4rTG6orPS2CRNFX3njhUXx5vj9qGog5ZMH4uGReDWN5kCkY3jmWEtWause41CDvBRXD1shKknAMKxT99o9qUTRVC6m")?;
/// let wallet: OfflineWallet<_> = Wallet::new_offline(
-/// BIP84(key.clone(), ScriptType::External),
-/// Some(BIP84(key, ScriptType::Internal)),
+/// BIP84(key.clone(), KeychainKind::External),
+/// Some(BIP84(key, KeychainKind::Internal)),
/// Network::Testnet,
/// MemoryDatabase::default()
/// )?;
///
/// assert_eq!(wallet.get_new_address()?.to_string(), "tb1qedg9fdlf8cnnqfd5mks6uz5w4kgpk2pr6y4qc7");
-/// assert_eq!(wallet.public_descriptor(ScriptType::External)?.unwrap().to_string(), "wpkh([c55b303f/84\'/0\'/0\']tpubDC2Qwo2TFsaNC4ju8nrUJ9mqVT3eSgdmy1yPqhgkjwmke3PRXutNGRYAUo6RCHTcVQaDR3ohNU9we59brGHuEKPvH1ags2nevW5opEE9Z5Q/0/*)");
+/// assert_eq!(wallet.public_descriptor(KeychainKind::External)?.unwrap().to_string(), "wpkh([c55b303f/84\'/0\'/0\']tpubDC2Qwo2TFsaNC4ju8nrUJ9mqVT3eSgdmy1yPqhgkjwmke3PRXutNGRYAUo6RCHTcVQaDR3ohNU9we59brGHuEKPvH1ags2nevW5opEE9Z5Q/0/*)");
/// # Ok::<_, Box<dyn std::error::Error>>(())
/// ```
-pub struct BIP84<K: DerivableKey<Segwitv0>>(pub K, pub ScriptType);
+pub struct BIP84<K: DerivableKey<Segwitv0>>(pub K, pub KeychainKind);
impl<K: DerivableKey<Segwitv0>> DescriptorTemplate for BIP84<K> {
fn build(self) -> Result<DescriptorTemplateOut, KeyError> {
/// ```
/// # use std::str::FromStr;
/// # use bdk::bitcoin::{PrivateKey, Network};
-/// # use bdk::{Wallet, OfflineWallet, ScriptType};
+/// # use bdk::{Wallet, OfflineWallet, KeychainKind};
/// # use bdk::database::MemoryDatabase;
/// use bdk::template::BIP84Public;
///
/// let key = bitcoin::util::bip32::ExtendedPubKey::from_str("tpubDC2Qwo2TFsaNC4ju8nrUJ9mqVT3eSgdmy1yPqhgkjwmke3PRXutNGRYAUo6RCHTcVQaDR3ohNU9we59brGHuEKPvH1ags2nevW5opEE9Z5Q")?;
/// let fingerprint = bitcoin::util::bip32::Fingerprint::from_str("c55b303f")?;
/// let wallet: OfflineWallet<_> = Wallet::new_offline(
-/// BIP84Public(key.clone(), fingerprint, ScriptType::External),
-/// Some(BIP84Public(key, fingerprint, ScriptType::Internal)),
+/// BIP84Public(key.clone(), fingerprint, KeychainKind::External),
+/// Some(BIP84Public(key, fingerprint, KeychainKind::Internal)),
/// Network::Testnet,
/// MemoryDatabase::default()
/// )?;
///
/// assert_eq!(wallet.get_new_address()?.to_string(), "tb1qedg9fdlf8cnnqfd5mks6uz5w4kgpk2pr6y4qc7");
-/// assert_eq!(wallet.public_descriptor(ScriptType::External)?.unwrap().to_string(), "wpkh([c55b303f/84\'/0\'/0\']tpubDC2Qwo2TFsaNC4ju8nrUJ9mqVT3eSgdmy1yPqhgkjwmke3PRXutNGRYAUo6RCHTcVQaDR3ohNU9we59brGHuEKPvH1ags2nevW5opEE9Z5Q/0/*)");
+/// assert_eq!(wallet.public_descriptor(KeychainKind::External)?.unwrap().to_string(), "wpkh([c55b303f/84\'/0\'/0\']tpubDC2Qwo2TFsaNC4ju8nrUJ9mqVT3eSgdmy1yPqhgkjwmke3PRXutNGRYAUo6RCHTcVQaDR3ohNU9we59brGHuEKPvH1ags2nevW5opEE9Z5Q/0/*)");
/// # Ok::<_, Box<dyn std::error::Error>>(())
/// ```
-pub struct BIP84Public<K: DerivableKey<Segwitv0>>(pub K, pub bip32::Fingerprint, pub ScriptType);
+pub struct BIP84Public<K: DerivableKey<Segwitv0>>(pub K, pub bip32::Fingerprint, pub KeychainKind);
impl<K: DerivableKey<Segwitv0>> DescriptorTemplate for BIP84Public<K> {
fn build(self) -> Result<DescriptorTemplateOut, KeyError> {
pub(super) fn make_bipxx_private<K: DerivableKey<$ctx>>(
bip: u32,
key: K,
- script_type: ScriptType,
+ keychain: KeychainKind,
) -> Result<impl ToDescriptorKey<$ctx>, KeyError> {
let mut derivation_path = Vec::with_capacity(4);
derivation_path.push(bip32::ChildNumber::from_hardened_idx(bip)?);
derivation_path.push(bip32::ChildNumber::from_hardened_idx(0)?);
derivation_path.push(bip32::ChildNumber::from_hardened_idx(0)?);
- match script_type {
- ScriptType::External => {
+ match keychain {
+ KeychainKind::External => {
derivation_path.push(bip32::ChildNumber::from_normal_idx(0)?)
}
- ScriptType::Internal => {
+ KeychainKind::Internal => {
derivation_path.push(bip32::ChildNumber::from_normal_idx(1)?)
}
};
bip: u32,
key: K,
parent_fingerprint: bip32::Fingerprint,
- script_type: ScriptType,
+ keychain: KeychainKind,
) -> Result<impl ToDescriptorKey<$ctx>, KeyError> {
- let derivation_path: bip32::DerivationPath = match script_type {
- ScriptType::External => vec![bip32::ChildNumber::from_normal_idx(0)?].into(),
- ScriptType::Internal => vec![bip32::ChildNumber::from_normal_idx(1)?].into(),
+ let derivation_path: bip32::DerivationPath = match keychain {
+ KeychainKind::External => vec![bip32::ChildNumber::from_normal_idx(0)?].into(),
+ KeychainKind::Internal => vec![bip32::ChildNumber::from_normal_idx(1)?].into(),
};
let mut source_path = Vec::with_capacity(3);
fn test_bip44_template() {
let prvkey = bitcoin::util::bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy").unwrap();
check(
- BIP44(prvkey, ScriptType::External).build(),
+ BIP44(prvkey, KeychainKind::External).build(),
false,
false,
&[
],
);
check(
- BIP44(prvkey, ScriptType::Internal).build(),
+ BIP44(prvkey, KeychainKind::Internal).build(),
false,
false,
&[
let pubkey = bitcoin::util::bip32::ExtendedPubKey::from_str("tpubDDDzQ31JkZB7VxUr9bjvBivDdqoFLrDPyLWtLapArAi51ftfmCb2DPxwLQzX65iNcXz1DGaVvyvo6JQ6rTU73r2gqdEo8uov9QKRb7nKCSU").unwrap();
let fingerprint = bitcoin::util::bip32::Fingerprint::from_str("c55b303f").unwrap();
check(
- BIP44Public(pubkey, fingerprint, ScriptType::External).build(),
+ BIP44Public(pubkey, fingerprint, KeychainKind::External).build(),
false,
false,
&[
],
);
check(
- BIP44Public(pubkey, fingerprint, ScriptType::Internal).build(),
+ BIP44Public(pubkey, fingerprint, KeychainKind::Internal).build(),
false,
false,
&[
fn test_bip49_template() {
let prvkey = bitcoin::util::bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy").unwrap();
check(
- BIP49(prvkey, ScriptType::External).build(),
+ BIP49(prvkey, KeychainKind::External).build(),
true,
false,
&[
],
);
check(
- BIP49(prvkey, ScriptType::Internal).build(),
+ BIP49(prvkey, KeychainKind::Internal).build(),
true,
false,
&[
let pubkey = bitcoin::util::bip32::ExtendedPubKey::from_str("tpubDC49r947KGK52X5rBWS4BLs5m9SRY3pYHnvRrm7HcybZ3BfdEsGFyzCMzayi1u58eT82ZeyFZwH7DD6Q83E3fM9CpfMtmnTygnLfP59jL9L").unwrap();
let fingerprint = bitcoin::util::bip32::Fingerprint::from_str("c55b303f").unwrap();
check(
- BIP49Public(pubkey, fingerprint, ScriptType::External).build(),
+ BIP49Public(pubkey, fingerprint, KeychainKind::External).build(),
true,
false,
&[
],
);
check(
- BIP49Public(pubkey, fingerprint, ScriptType::Internal).build(),
+ BIP49Public(pubkey, fingerprint, KeychainKind::Internal).build(),
true,
false,
&[
fn test_bip84_template() {
let prvkey = bitcoin::util::bip32::ExtendedPrivKey::from_str("tprv8ZgxMBicQKsPcx5nBGsR63Pe8KnRUqmbJNENAfGftF3yuXoMMoVJJcYeUw5eVkm9WBPjWYt6HMWYJNesB5HaNVBaFc1M6dRjWSYnmewUMYy").unwrap();
check(
- BIP84(prvkey, ScriptType::External).build(),
+ BIP84(prvkey, KeychainKind::External).build(),
true,
false,
&[
],
);
check(
- BIP84(prvkey, ScriptType::Internal).build(),
+ BIP84(prvkey, KeychainKind::Internal).build(),
true,
false,
&[
let pubkey = bitcoin::util::bip32::ExtendedPubKey::from_str("tpubDC2Qwo2TFsaNC4ju8nrUJ9mqVT3eSgdmy1yPqhgkjwmke3PRXutNGRYAUo6RCHTcVQaDR3ohNU9we59brGHuEKPvH1ags2nevW5opEE9Z5Q").unwrap();
let fingerprint = bitcoin::util::bip32::Fingerprint::from_str("c55b303f").unwrap();
check(
- BIP84Public(pubkey, fingerprint, ScriptType::External).build(),
+ BIP84Public(pubkey, fingerprint, KeychainKind::External).build(),
true,
false,
&[
],
);
check(
- BIP84Public(pubkey, fingerprint, ScriptType::Internal).build(),
+ BIP84Public(pubkey, fingerprint, KeychainKind::Internal).build(),
true,
false,
&[
Key(crate::keys::KeyError),
/// Descriptor checksum mismatch
ChecksumMismatch,
- /// Spending policy is not compatible with this [`ScriptType`](crate::types::ScriptType)
- SpendingPolicyRequired(crate::types::ScriptType),
+ /// Spending policy is not compatible with this [`KeychainKind`](crate::types::KeychainKind)
+ SpendingPolicyRequired(crate::types::KeychainKind),
#[allow(missing_docs)]
InvalidPolicyPathError(crate::descriptor::policy::PolicyError),
#[allow(missing_docs)]
/// Types of script
#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq, Eq, Hash)]
-pub enum ScriptType {
+pub enum KeychainKind {
/// External
External = 0,
/// Internal, usually used for change outputs
Internal = 1,
}
-impl ScriptType {
+impl KeychainKind {
pub fn as_byte(&self) -> u8 {
match self {
- ScriptType::External => b'e',
- ScriptType::Internal => b'i',
+ KeychainKind::External => b'e',
+ KeychainKind::Internal => b'i',
}
}
}
-impl AsRef<[u8]> for ScriptType {
+impl AsRef<[u8]> for KeychainKind {
fn as_ref(&self) -> &[u8] {
match self {
- ScriptType::External => b"e",
- ScriptType::Internal => b"i",
+ KeychainKind::External => b"e",
+ KeychainKind::Internal => b"i",
}
}
}
pub struct UTXO {
pub outpoint: OutPoint,
pub txout: TxOut,
- pub script_type: ScriptType,
+ pub keychain: KeychainKind,
}
/// A wallet transaction
//! impl AddressValidator for PrintAddressAndContinue {
//! fn validate(
//! &self,
-//! script_type: ScriptType,
+//! keychain: KeychainKind,
//! hd_keypaths: &HDKeyPaths,
//! script: &Script
//! ) -> Result<(), AddressValidatorError> {
//! .as_ref()
//! .map(Address::to_string)
//! .unwrap_or(script.to_string());
-//! println!("New address of type {:?}: {}", script_type, address);
+//! println!("New address of type {:?}: {}", keychain, address);
//! println!("HD keypaths: {:#?}", hd_keypaths);
//!
//! Ok(())
use bitcoin::Script;
use crate::descriptor::HDKeyPaths;
-use crate::types::ScriptType;
+use crate::types::KeychainKind;
/// Errors that can be returned to fail the validation of an address
#[derive(Debug, Clone, PartialEq, Eq)]
/// Validate or inspect an address
fn validate(
&self,
- script_type: ScriptType,
+ keychain: KeychainKind,
hd_keypaths: &HDKeyPaths,
script: &Script,
) -> Result<(), AddressValidatorError>;
impl AddressValidator for TestValidator {
fn validate(
&self,
- _script_type: ScriptType,
+ _keychain: KeychainKind,
_hd_keypaths: &HDKeyPaths,
_script: &bitcoin::Script,
) -> Result<(), AddressValidatorError> {
value: 100_000,
script_pubkey: Script::new(),
},
- script_type: ScriptType::External,
+ keychain: KeychainKind::External,
},
P2WPKH_WITNESS_SIZE,
),
value: 200_000,
script_pubkey: Script::new(),
},
- script_type: ScriptType::Internal,
+ keychain: KeychainKind::Internal,
},
P2WPKH_WITNESS_SIZE,
),
value: rng.gen_range(0, 200000000),
script_pubkey: Script::new(),
},
- script_type: ScriptType::External,
+ keychain: KeychainKind::External,
},
P2WPKH_WITNESS_SIZE,
));
value: utxos_value,
script_pubkey: Script::new(),
},
- script_type: ScriptType::External,
+ keychain: KeychainKind::External,
},
P2WPKH_WITNESS_SIZE,
);
) -> Result<Self, Error> {
let (descriptor, keymap) = descriptor.to_wallet_descriptor(network)?;
database.check_descriptor_checksum(
- ScriptType::External,
+ KeychainKind::External,
get_checksum(&descriptor.to_string())?.as_bytes(),
)?;
let signers = Arc::new(SignersContainer::from(keymap));
Some(desc) => {
let (change_descriptor, change_keymap) = desc.to_wallet_descriptor(network)?;
database.check_descriptor_checksum(
- ScriptType::Internal,
+ KeychainKind::Internal,
get_checksum(&change_descriptor.to_string())?.as_bytes(),
)?;
/// Return a newly generated address using the external descriptor
pub fn get_new_address(&self) -> Result<Address, Error> {
- let index = self.fetch_and_increment_index(ScriptType::External)?;
+ let index = self.fetch_and_increment_index(KeychainKind::External)?;
let deriv_ctx = descriptor_to_pk_ctx(&self.secp);
self.descriptor
/// See [the `signer` module](signer) for an example.
pub fn add_signer(
&mut self,
- script_type: ScriptType,
+ keychain: KeychainKind,
id: SignerId,
ordering: SignerOrdering,
signer: Arc<dyn Signer>,
) {
- let signers = match script_type {
- ScriptType::External => Arc::make_mut(&mut self.signers),
- ScriptType::Internal => Arc::make_mut(&mut self.change_signers),
+ let signers = match keychain {
+ KeychainKind::External => Arc::make_mut(&mut self.signers),
+ KeychainKind::Internal => Arc::make_mut(&mut self.change_signers),
};
signers.add_external(id, ordering, signer);
&& external_policy.requires_path()
&& builder.external_policy_path.is_none()
{
- return Err(Error::SpendingPolicyRequired(ScriptType::External));
+ return Err(Error::SpendingPolicyRequired(KeychainKind::External));
};
// Same for the internal_policy path, if present
if let Some(internal_policy) = &internal_policy {
&& internal_policy.requires_path()
&& builder.internal_policy_path.is_none()
{
- return Err(Error::SpendingPolicyRequired(ScriptType::Internal));
+ return Err(Error::SpendingPolicyRequired(KeychainKind::Internal));
};
}
None => {
let mut change_output = None;
for (index, txout) in tx.output.iter().enumerate() {
- // look for an output that we know and that has the right ScriptType. We use
- // `get_descriptor_for` to find what's the ScriptType for `Internal`
+ // look for an output that we know and that has the right KeychainKind. We use
+ // `get_descriptor_for` to find what's the KeychainKind for `Internal`
// addresses really is, because if there's no change_descriptor it's actually equal
// to "External"
- let (_, change_type) =
- self.get_descriptor_for_script_type(ScriptType::Internal);
+ let (_, change_type) = self.get_descriptor_for_keychain(KeychainKind::Internal);
match self
.database
.borrow()
.get_path_from_script_pubkey(&txout.script_pubkey)?
{
- Some((script_type, _)) if script_type == change_type => {
+ Some((keychain, _)) if keychain == change_type => {
change_output = Some(index);
break;
}
.get_previous_output(&txin.previous_output)?
.ok_or(Error::UnknownUTXO)?;
- let (weight, script_type) = match self
+ let (weight, keychain) = match self
.database
.borrow()
.get_path_from_script_pubkey(&txout.script_pubkey)?
{
- Some((script_type, _)) => (
- self.get_descriptor_for_script_type(script_type)
+ Some((keychain, _)) => (
+ self.get_descriptor_for_keychain(keychain)
.0
.max_satisfaction_weight(deriv_ctx)
.unwrap(),
- script_type,
+ keychain,
),
None => {
// estimate the weight based on the scriptsig/witness size present in the
// original transaction
let weight =
serialize(&txin.script_sig).len() * 4 + serialize(&txin.witness).len();
- (weight, ScriptType::External)
+ (weight, KeychainKind::External)
}
};
let utxo = UTXO {
outpoint: txin.previous_output,
txout,
- script_type,
+ keychain,
};
Ok((utxo, weight))
}
/// Return the spending policies for the wallet's descriptor
- pub fn policies(&self,
script_type: ScriptType) -> Result<Option<Policy>, Error> {
- match (script_type, self.change_descriptor.as_ref()) {
- (ScriptType::External, _) => {
+ pub fn policies(&self,
keychain: KeychainKind) -> Result<Option<Policy>, Error> {
+ match (keychain, self.change_descriptor.as_ref()) {
+ (KeychainKind::External, _) => {
Ok(self.descriptor.extract_policy(&self.signers, &self.secp)?)
}
- (ScriptType::Internal, None) => Ok(None),
- (ScriptType::Internal, Some(desc)) => {
+ (KeychainKind::Internal, None) => Ok(None),
+ (KeychainKind::Internal, Some(desc)) => {
Ok(desc.extract_policy(&self.change_signers, &self.secp)?)
}
}
/// This can be used to build a watch-only version of a wallet
pub fn public_descriptor(
&self,
- script_type: ScriptType,
+ keychain: KeychainKind,
) -> Result<Option<ExtendedDescriptor>, Error> {
- match (script_type, self.change_descriptor.as_ref()) {
- (ScriptType::External, _) => Ok(Some(self.descriptor.clone())),
- (ScriptType::Internal, None) => Ok(None),
- (ScriptType::Internal, Some(desc)) => Ok(Some(desc.clone())),
+ match (keychain, self.change_descriptor.as_ref()) {
+ (KeychainKind::External, _) => Ok(Some(self.descriptor.clone())),
+ (KeychainKind::Internal, None) => Ok(None),
+ (KeychainKind::Internal, Some(desc)) => Ok(Some(desc.clone())),
}
}
);
// - Try to derive the descriptor by looking at the txout. If it's in our database, we
- // know exactly which `script_type` to use, and which derivation index it is
+ // know exactly which `keychain` to use, and which derivation index it is
// - If that fails, try to derive it by looking at the psbt input: the complete logic
// is in `src/descriptor/mod.rs`, but it will basically look at `hd_keypaths`,
// `redeem_script` and `witness_script` to determine the right derivation
// Internals
- fn get_descriptor_for_script_type(
+ fn get_descriptor_for_keychain(
&self,
- script_type: ScriptType,
- ) -> (&ExtendedDescriptor, ScriptType) {
- match script_type {
- ScriptType::Internal if self.change_descriptor.is_some() => (
+ keychain: KeychainKind,
+ ) -> (&ExtendedDescriptor, KeychainKind) {
+ match keychain {
+ KeychainKind::Internal if self.change_descriptor.is_some() => (
self.change_descriptor.as_ref().unwrap(),
- ScriptType::Internal,
+ KeychainKind::Internal,
),
- _ => (&self.descriptor, ScriptType::External),
+ _ => (&self.descriptor, KeychainKind::External),
}
}
.database
.borrow()
.get_path_from_script_pubkey(&txout.script_pubkey)?
- .map(|(script_type, child)| (self.get_descriptor_for_script_type(script_type).0, child))
+ .map(|(keychain, child)| (self.get_descriptor_for_keychain(keychain).0, child))
.map(|(desc, child)| desc.derive(ChildNumber::from_normal_idx(child).unwrap())))
}
fn get_change_address(&self) -> Result<Script, Error> {
let deriv_ctx = descriptor_to_pk_ctx(&self.secp);
- let (desc, script_type) = self.get_descriptor_for_script_type(ScriptType::Internal);
- let index = self.fetch_and_increment_index(script_type)?;
+ let (desc, keychain) = self.get_descriptor_for_keychain(KeychainKind::Internal);
+ let index = self.fetch_and_increment_index(keychain)?;
Ok(desc
.derive(ChildNumber::from_normal_idx(index)?)
.script_pubkey(deriv_ctx))
}
- fn fetch_and_increment_index(&self, script_type: ScriptType) -> Result<u32, Error> {
- let (descriptor, script_type) = self.get_descriptor_for_script_type(script_type);
+ fn fetch_and_increment_index(&self, keychain: KeychainKind) -> Result<u32, Error> {
+ let (descriptor, keychain) = self.get_descriptor_for_keychain(keychain);
let index = match descriptor.is_fixed() {
true => 0,
- false => self
- .database
- .borrow_mut()
- .increment_last_index(script_type)?,
+ false => self.database.borrow_mut().increment_last_index(keychain)?,
};
if self
.database
.borrow()
- .get_script_pubkey_from_path(script_type, index)?
+ .get_script_pubkey_from_path(keychain, index)?
.is_none()
{
- self.cache_addresses(script_type, index, CACHE_ADDR_BATCH_SIZE)?;
+ self.cache_addresses(keychain, index, CACHE_ADDR_BATCH_SIZE)?;
}
let deriv_ctx = descriptor_to_pk_ctx(&self.secp);
.derive(ChildNumber::from_normal_idx(index)?)
.script_pubkey(deriv_ctx);
for validator in &self.address_validators {
- validator.validate(script_type, &hd_keypaths, &script)?;
+ validator.validate(keychain, &hd_keypaths, &script)?;
}
Ok(index)
fn cache_addresses(
&self,
- script_type: ScriptType,
+ keychain: KeychainKind,
from: u32,
mut count: u32,
) -> Result<(), Error> {
- let (descriptor, script_type) = self.get_descriptor_for_script_type(script_type);
+ let (descriptor, keychain) = self.get_descriptor_for_keychain(keychain);
if descriptor.is_fixed() {
if from > 0 {
return Ok(());
&descriptor
.derive(ChildNumber::from_normal_idx(i)?)
.script_pubkey(deriv_ctx),
- script_type,
+ keychain,
i,
)?;
}
.list_unspent()?
.into_iter()
.map(|utxo| {
- let script_type = utxo.script_type;
+ let keychain = utxo.keychain;
(
utxo,
- self.get_descriptor_for_script_type(script_type)
+ self.get_descriptor_for_keychain(keychain)
.0
.max_satisfaction_weight(deriv_ctx)
.unwrap(),
// Try to find the prev_script in our db to figure out if this is internal or external,
// and the derivation index
- let (script_type, child) = match self
+ let (keychain, child) = match self
.database
.borrow()
.get_path_from_script_pubkey(&utxo.txout.script_pubkey)?
None => continue,
};
- let (desc, _) = self.get_descriptor_for_script_type(script_type);
+ let (desc, _) = self.get_descriptor_for_keychain(keychain);
psbt_input.hd_keypaths = desc.get_hd_keypaths(child, &self.secp)?;
let derived_descriptor = desc.derive(ChildNumber::from_normal_idx(child)?);
.iter_mut()
.zip(psbt.global.unsigned_tx.output.iter())
{
- if let Some((script_type, child)) = self
+ if let Some((keychain, child)) = self
.database
.borrow()
.get_path_from_script_pubkey(&tx_output.script_pubkey)?
{
- let (desc, _) = self.get_descriptor_for_script_type(script_type);
+ let (desc, _) = self.get_descriptor_for_keychain(keychain);
psbt_output.hd_keypaths = desc.get_hd_keypaths(child, &self.secp)?;
if builder.include_output_redeem_witness_script {
let derived_descriptor = desc.derive(ChildNumber::from_normal_idx(child)?);
// try to add hd_keypaths if we've already seen the output
for (psbt_input, out) in psbt.inputs.iter_mut().zip(input_utxos.iter()) {
if let Some(out) = out {
- if let Some((script_type, child)) = self
+ if let Some((keychain, child)) = self
.database
.borrow()
.get_path_from_script_pubkey(&out.script_pubkey)?
{
- debug!("Found descriptor {:?}/{}", script_type, child);
+ debug!("Found descriptor {:?}/{}", keychain, child);
// merge hd_keypaths
- let (desc, _) = self.get_descriptor_for_script_type(script_type);
+ let (desc, _) = self.get_descriptor_for_keychain(keychain);
let mut hd_keypaths = desc.get_hd_keypaths(child, &self.secp)?;
psbt_input.hd_keypaths.append(&mut hd_keypaths);
}
if self
.database
.borrow()
- .get_script_pubkey_from_path(ScriptType::External, max_address.saturating_sub(1))?
+ .get_script_pubkey_from_path(KeychainKind::External, max_address.saturating_sub(1))?
.is_none()
{
run_setup = true;
- self.cache_addresses(ScriptType::External, 0, max_address)?;
+ self.cache_addresses(KeychainKind::External, 0, max_address)?;
}
if let Some(change_descriptor) = &self.change_descriptor {
if self
.database
.borrow()
- .get_script_pubkey_from_path(ScriptType::Internal, max_address.saturating_sub(1))?
+ .get_script_pubkey_from_path(KeychainKind::Internal, max_address.saturating_sub(1))?
.is_none()
{
run_setup = true;
- self.cache_addresses(ScriptType::Internal, 0, max_address)?;
+ self.cache_addresses(KeychainKind::Internal, 0, max_address)?;
}
}
use crate::database::memory::MemoryDatabase;
use crate::database::Database;
- use crate::types::ScriptType;
+ use crate::types::KeychainKind;
use super::*;
assert!(wallet
.database
.borrow_mut()
- .get_script_pubkey_from_path(ScriptType::External, 0)
+ .get_script_pubkey_from_path(KeychainKind::External, 0)
.unwrap()
.is_some());
assert!(wallet
.database
.borrow_mut()
- .get_script_pubkey_from_path(ScriptType::Internal, 0)
+ .get_script_pubkey_from_path(KeychainKind::Internal, 0)
.unwrap()
.is_none());
}
assert!(wallet
.database
.borrow_mut()
- .get_script_pubkey_from_path(ScriptType::External, CACHE_ADDR_BATCH_SIZE - 1)
+ .get_script_pubkey_from_path(KeychainKind::External, CACHE_ADDR_BATCH_SIZE - 1)
.unwrap()
.is_some());
assert!(wallet
.database
.borrow_mut()
- .get_script_pubkey_from_path(ScriptType::External, CACHE_ADDR_BATCH_SIZE)
+ .get_script_pubkey_from_path(KeychainKind::External, CACHE_ADDR_BATCH_SIZE)
.unwrap()
.is_none());
}
assert!(wallet
.database
.borrow_mut()
- .get_script_pubkey_from_path(ScriptType::External, CACHE_ADDR_BATCH_SIZE - 1)
+ .get_script_pubkey_from_path(KeychainKind::External, CACHE_ADDR_BATCH_SIZE - 1)
.unwrap()
.is_some());
assert!(wallet
.database
.borrow_mut()
- .get_script_pubkey_from_path(ScriptType::External, CACHE_ADDR_BATCH_SIZE * 2 - 1)
+ .get_script_pubkey_from_path(KeychainKind::External, CACHE_ADDR_BATCH_SIZE * 2 - 1)
.unwrap()
.is_some());
}
fn test_create_tx_policy_path_no_csv() {
let (wallet, _, _) = get_funded_wallet(get_test_a_or_b_plus_csv());
- let external_policy = wallet.policies(ScriptType::External).unwrap().unwrap();
+ let external_policy = wallet.policies(KeychainKind::External).unwrap().unwrap();
let root_id = external_policy.id;
// child #0 is just the key "A"
let path = vec![(root_id, vec![0])].into_iter().collect();
let (psbt, _) = wallet
.create_tx(
TxBuilder::with_recipients(vec![(addr.script_pubkey(), 30_000)])
- .policy_path(path, ScriptType::External),
+ .policy_path(path, KeychainKind::External),
)
.unwrap();
fn test_create_tx_policy_path_use_csv() {
let (wallet, _, _) = get_funded_wallet(get_test_a_or_b_plus_csv());
- let external_policy = wallet.policies(ScriptType::External).unwrap().unwrap();
+ let external_policy = wallet.policies(KeychainKind::External).unwrap().unwrap();
let root_id = external_policy.id;
// child #1 is or(pk(B),older(144))
let path = vec![(root_id, vec![1])].into_iter().collect();
let (psbt, _) = wallet
.create_tx(
TxBuilder::with_recipients(vec![(addr.script_pubkey(), 30_000)])
- .policy_path(path, ScriptType::External),
+ .policy_path(path, KeychainKind::External),
)
.unwrap();
//! let descriptor = "wpkh(tpubD6NzVbkrYhZ4Xferm7Pz4VnjdcDPFyjVu5K4iZXQ4pVN8Cks4pHVowTBXBKRhX64pkRyJZJN5xAKj4UDNnLPb5p2sSKXhewoYx5GbTdUFWq/*)";
//! let mut wallet: OfflineWallet<_> = Wallet::new_offline(descriptor, None, Network::Testnet, MemoryDatabase::default())?;
//! wallet.add_signer(
-//! ScriptType::External,
+//! KeychainKind::External,
//! Fingerprint::from_str("e30f11b8").unwrap().into(),
//! SignerOrdering(200),
//! Arc::new(custom_signer)
use super::coin_selection::{CoinSelectionAlgorithm, DefaultCoinSelectionAlgorithm};
use crate::database::Database;
-use crate::types::{FeeRate, ScriptType, UTXO};
+use crate::types::{FeeRate, KeychainKind, UTXO};
/// Context in which the [`TxBuilder`] is valid
pub trait TxBuilderContext: std::fmt::Debug + Default + Clone {}
/// path.insert("aabbccdd".to_string(), vec![0, 1]);
///
/// let builder = TxBuilder::with_recipients(vec![(to_address.script_pubkey(), 50_000)])
- /// .policy_path(path, ScriptType::External);
+ /// .policy_path(path, KeychainKind::External);
/// # let builder: TxBuilder<bdk::database::MemoryDatabase, _, _> = builder;
/// ```
pub fn policy_path(
mut self,
policy_path: BTreeMap<String, Vec<usize>>,
- script_type: ScriptType,
+ keychain: KeychainKind,
) -> Self {
- let to_update = match script_type {
- ScriptType::Internal => &mut self.internal_policy_path,
- ScriptType::External => &mut self.external_policy_path,
+ let to_update = match keychain {
+ KeychainKind::Internal => &mut self.internal_policy_path,
+ KeychainKind::External => &mut self.external_policy_path,
};
*to_update = Some(policy_path);
pub(crate) fn is_satisfied_by(&self, utxo: &UTXO) -> bool {
match self {
ChangeSpendPolicy::ChangeAllowed => true,
- ChangeSpendPolicy::OnlyChange => utxo.script_type == ScriptType::Internal,
- ChangeSpendPolicy::ChangeForbidden => utxo.script_type == ScriptType::External,
+ ChangeSpendPolicy::OnlyChange => utxo.keychain == KeychainKind::Internal,
+ ChangeSpendPolicy::ChangeForbidden => utxo.keychain == KeychainKind::External,
}
}
}
vout: 0,
},
txout: Default::default(),
- script_type: ScriptType::External,
+ keychain: KeychainKind::External,
},
UTXO {
outpoint: OutPoint {
vout: 1,
},
txout: Default::default(),
- script_type: ScriptType::Internal,
+ keychain: KeychainKind::Internal,
},
]
}
.collect::<Vec<_>>();
assert_eq!(filtered.len(), 1);
- assert_eq!(filtered[0].script_type, ScriptType::External);
+ assert_eq!(filtered[0].keychain, KeychainKind::External);
}
#[test]
.collect::<Vec<_>>();
assert_eq!(filtered.len(), 1);
- assert_eq!(filtered[0].script_type, ScriptType::Internal);
+ assert_eq!(filtered[0].keychain, KeychainKind::Internal);
}
#[test]
use #root_ident::blockchain::{Blockchain, noop_progress};
use #root_ident::descriptor::ExtendedDescriptor;
use #root_ident::database::MemoryDatabase;
- use #root_ident::types::ScriptType;
+ use #root_ident::types::KeychainKind;
use #root_ident::{Wallet, TxBuilder, FeeRate};
use super::*;
wallet.sync(noop_progress(), None).unwrap();
assert_eq!(wallet.get_balance().unwrap(), 50_000);
- assert_eq!(wallet.list_unspent().unwrap()[0].script_type, ScriptType::External);
+ assert_eq!(wallet.list_unspent().unwrap()[0].keychain, KeychainKind::External);
let list_tx_item = &wallet.list_transactions(false).unwrap()[0];
assert_eq!(list_tx_item.txid, txid);
projects / bdk / commitdiff