milksad
/
rust-bitcoin-unsafe-fast
14
0
Fork 0
Code Issues Pull Requests Activity

Merge rust-bitcoin/rust-bitcoin#2019: Rename xpub and xpriv types 

be05f9d852 Rename xpub and xpriv types (Tobin C. Harding)

Pull request description:

  The BIP-32 extended public key and extended private key exist in the Bitcoin vernacular as xpub and xpriv. We can use these terms with no loss of clarity.

  Rename our current BIP-32 types

  - `ExtendedPubKey` to `Xpub`
  - `ExtendedPrivKey` to `Xpriv`

  This patch is a mechanical search-and-replace, followed by running the formatter, no other manual changes.

ACKs for top commit:
  apoelstra:
    ACK be05f9d852
  sanket1729:
    ACK be05f9d852

Tree-SHA512: 49925688783c3f37a9b92a9767a0df095323a3fa51f3d672a0b5dd1d8bca86f7facbcc33921274bc147b369de09042c4850b08c31e63f71110903435daa6c00c
This commit is contained in:
Andrew Poelstra 2023-08-25 13:27:20 +00:00
parent bd05e3f309 be05f9d852
commit 082bd03120
No known key found for this signature in database
GPG Key ID: C588D63CE41B97C1
9 changed files with 100 additions and 114 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
bitcoin/examples/bip32.rs
View File

@ -4,7 +4,7 @@ use std::str::FromStr;
use std::{env, process};
use bitcoin::address::Address;
use bitcoin::bip32::{ChildNumber, DerivationPath, ExtendedPrivKey, ExtendedPubKey};
use bitcoin::bip32::{ChildNumber, DerivationPath, Xpriv, Xpub};
use bitcoin::hex::FromHex;
use bitcoin::secp256k1::ffi::types::AlignedType;
use bitcoin::secp256k1::Secp256k1;
@ -39,14 +39,14 @@ fn main() {
let secp = Secp256k1::preallocated_new(buf.as_mut_slice()).unwrap();
// calculate root key from seed
let root = ExtendedPrivKey::new_master(network, &seed).unwrap();
let root = Xpriv::new_master(network, &seed).unwrap();
println!("Root key: {}", root);
// derive child xpub
let path = DerivationPath::from_str("m/84h/0h/0h").unwrap();
let child = root.derive_priv(&secp, &path).unwrap();
println!("Child at {}: {}", path, child);
let xpub = ExtendedPubKey::from_priv(&secp, &child);
let xpub = Xpub::from_priv(&secp, &child);
println!("Public key at {}: {}", path, xpub);
// generate first receiving address at m/0/0

28
bitcoin/examples/ecdsa-psbt.rs
View File

@ -33,9 +33,7 @@ use std::collections::BTreeMap;
use std::fmt;
use std::str::FromStr;
use bitcoin::bip32::{
ChildNumber, DerivationPath, ExtendedPrivKey, ExtendedPubKey, Fingerprint, IntoDerivationPath,
};
use bitcoin::bip32::{ChildNumber, DerivationPath, Fingerprint, IntoDerivationPath, Xpriv, Xpub};
use bitcoin::consensus::encode;
use bitcoin::locktime::absolute;
use bitcoin::psbt::{self, Input, Psbt, PsbtSighashType};
@ -97,14 +95,14 @@ fn main() -> Result<()> {
/// An example of an offline signer i.e., a cold-storage device.
struct ColdStorage {
/// The master extended private key.
master_xpriv: ExtendedPrivKey,
master_xpriv: Xpriv,
/// The master extended public key.
master_xpub: ExtendedPubKey,
master_xpub: Xpub,
}
/// The data exported from an offline wallet to enable creation of a watch-only online wallet.
/// (wallet, fingerprint, account_0_xpub, input_utxo_xpub)
type ExportData = (ColdStorage, Fingerprint, ExtendedPubKey, ExtendedPubKey);
type ExportData = (ColdStorage, Fingerprint, Xpub, Xpub);
impl ColdStorage {
/// Constructs a new `ColdStorage` signer.
@ -113,18 +111,18 @@ impl ColdStorage {
///
/// The newly created signer along with the data needed to configure a watch-only wallet.
fn new<C: Signing>(secp: &Secp256k1<C>, xpriv: &str) -> Result<ExportData> {
let master_xpriv = ExtendedPrivKey::from_str(xpriv)?;
let master_xpub = ExtendedPubKey::from_priv(secp, &master_xpriv);
let master_xpriv = Xpriv::from_str(xpriv)?;
let master_xpub = Xpub::from_priv(secp, &master_xpriv);
// Hardened children require secret data to derive.
let path = "m/84h/0h/0h".into_derivation_path()?;
let account_0_xpriv = master_xpriv.derive_priv(secp, &path)?;
let account_0_xpub = ExtendedPubKey::from_priv(secp, &account_0_xpriv);
let account_0_xpub = Xpub::from_priv(secp, &account_0_xpriv);
let path = INPUT_UTXO_DERIVATION_PATH.into_derivation_path()?;
let input_xpriv = master_xpriv.derive_priv(secp, &path)?;
let input_xpub = ExtendedPubKey::from_priv(secp, &input_xpriv);
let input_xpub = Xpub::from_priv(secp, &input_xpriv);
let wallet = ColdStorage { master_xpriv, master_xpub };
let fingerprint = wallet.master_fingerprint();
@ -151,9 +149,9 @@ impl ColdStorage {
/// An example of an watch-only online wallet.
struct WatchOnly {
/// The xpub for account 0 derived from derivation path "m/84h/0h/0h".
account_0_xpub: ExtendedPubKey,
account_0_xpub: Xpub,
/// The xpub derived from `INPUT_UTXO_DERIVATION_PATH`.
input_xpub: ExtendedPubKey,
input_xpub: Xpub,
/// The master extended pubkey fingerprint.
master_fingerprint: Fingerprint,
}
@ -166,11 +164,7 @@ impl WatchOnly {
///
/// The reason for importing the `input_xpub` is so one can use bitcoind to grab a valid input
/// to verify the workflow presented in this file.
fn new(
account_0_xpub: ExtendedPubKey,
input_xpub: ExtendedPubKey,
master_fingerprint: Fingerprint,
) -> Self {
fn new(account_0_xpub: Xpub, input_xpub: Xpub, master_fingerprint: Fingerprint) -> Self {
WatchOnly { account_0_xpub, input_xpub, master_fingerprint }
}

32
bitcoin/examples/taproot-psbt.rs
View File

@ -78,7 +78,7 @@ const UTXO_3: P2trUtxo = P2trUtxo {
use std::collections::BTreeMap;
use std::str::FromStr;
use bitcoin::bip32::{ChildNumber, DerivationPath, ExtendedPrivKey, ExtendedPubKey, Fingerprint};
use bitcoin::bip32::{ChildNumber, DerivationPath, Fingerprint, Xpriv, Xpub};
use bitcoin::consensus::encode;
use bitcoin::hashes::Hash;
use bitcoin::key::{TapTweak, XOnlyPublicKey};
@ -115,7 +115,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
let tx_hex_string = encode::serialize_hex(&generate_bip86_key_spend_tx(
&secp,
// The master extended private key from the descriptor in step 4
ExtendedPrivKey::from_str(BENEFACTOR_XPRIV_STR)?,
Xpriv::from_str(BENEFACTOR_XPRIV_STR)?,
// Set these fields with valid data for the UTXO from step 5 above
UTXO_1,
vec![
@ -134,11 +134,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
println!("START EXAMPLE 2 - Script path spending of inheritance UTXO\n");
{
let beneficiary =
BeneficiaryWallet::new(ExtendedPrivKey::from_str(BENEFICIARY_XPRIV_STR)?)?;
let beneficiary = BeneficiaryWallet::new(Xpriv::from_str(BENEFICIARY_XPRIV_STR)?)?;
let mut benefactor = BenefactorWallet::new(
ExtendedPrivKey::from_str(BENEFACTOR_XPRIV_STR)?,
Xpriv::from_str(BENEFACTOR_XPRIV_STR)?,
beneficiary.master_xpub(),
)?;
let (tx, psbt) = benefactor.create_inheritance_funding_tx(
@ -173,11 +172,10 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
println!("START EXAMPLE 3 - Key path spending of inheritance UTXO\n");
{
let beneficiary =
BeneficiaryWallet::new(ExtendedPrivKey::from_str(BENEFICIARY_XPRIV_STR)?)?;
let beneficiary = BeneficiaryWallet::new(Xpriv::from_str(BENEFICIARY_XPRIV_STR)?)?;
let mut benefactor = BenefactorWallet::new(
ExtendedPrivKey::from_str(BENEFACTOR_XPRIV_STR)?,
Xpriv::from_str(BENEFACTOR_XPRIV_STR)?,
beneficiary.master_xpub(),
)?;
let (tx, _) = benefactor.create_inheritance_funding_tx(
@ -222,7 +220,7 @@ struct P2trUtxo<'a> {
fn generate_bip86_key_spend_tx(
secp: &secp256k1::Secp256k1<secp256k1::All>,
master_xpriv: ExtendedPrivKey,
master_xpriv: Xpriv,
input_utxo: P2trUtxo,
outputs: Vec<TxOut>,
) -> Result<Transaction, Box<dyn std::error::Error>> {
@ -336,8 +334,8 @@ fn generate_bip86_key_spend_tx(
/// A wallet that allows creating and spending from an inheritance directly via the key path for purposes
/// of refreshing the inheritance timelock or changing other spending conditions.
struct BenefactorWallet {
master_xpriv: ExtendedPrivKey,
beneficiary_xpub: ExtendedPubKey,
master_xpriv: Xpriv,
beneficiary_xpub: Xpub,
current_spend_info: Option<TaprootSpendInfo>,
next_psbt: Option<Psbt>,
secp: Secp256k1<secp256k1::All>,
@ -346,8 +344,8 @@ struct BenefactorWallet {
impl BenefactorWallet {
fn new(
master_xpriv: ExtendedPrivKey,
beneficiary_xpub: ExtendedPubKey,
master_xpriv: Xpriv,
beneficiary_xpub: Xpub,
) -> Result<Self, Box<dyn std::error::Error>> {
Ok(Self {
master_xpriv,
@ -616,18 +614,16 @@ impl BenefactorWallet {
/// A wallet that allows spending from an inheritance locked to a P2TR UTXO via a script path
/// after some expiry using CLTV.
struct BeneficiaryWallet {
master_xpriv: ExtendedPrivKey,
master_xpriv: Xpriv,
secp: secp256k1::Secp256k1<secp256k1::All>,
}
impl BeneficiaryWallet {
fn new(master_xpriv: ExtendedPrivKey) -> Result<Self, Box<dyn std::error::Error>> {
fn new(master_xpriv: Xpriv) -> Result<Self, Box<dyn std::error::Error>> {
Ok(Self { master_xpriv, secp: Secp256k1::new() })
}
fn master_xpub(&self) -> ExtendedPubKey {
ExtendedPubKey::from_priv(&self.secp, &self.master_xpriv)
}
fn master_xpub(&self) -> Xpub { Xpub::from_priv(&self.secp, &self.master_xpriv) }
fn spend_inheritance(
&self,

99
bitcoin/src/bip32.rs
View File

@ -47,7 +47,7 @@ impl_bytes_newtype!(Fingerprint, 4);
/// Extended private key
#[derive(Copy, Clone, PartialEq, Eq)]
#[cfg_attr(feature = "std", derive(Debug))]
pub struct ExtendedPrivKey {
pub struct Xpriv {
/// The network this key is to be used on
pub network: Network,
/// How many derivations this key is from the master (which is 0)
@ -62,12 +62,12 @@ pub struct ExtendedPrivKey {
pub chain_code: ChainCode,
}
#[cfg(feature = "serde")]
crate::serde_utils::serde_string_impl!(ExtendedPrivKey, "a BIP-32 extended private key");
crate::serde_utils::serde_string_impl!(Xpriv, "a BIP-32 extended private key");
#[cfg(not(feature = "std"))]
impl fmt::Debug for ExtendedPrivKey {
impl fmt::Debug for Xpriv {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
f.debug_struct("ExtendedPrivKey")
f.debug_struct("Xpriv")
.field("network", &self.network)
.field("depth", &self.depth)
.field("parent_fingerprint", &self.parent_fingerprint)
@ -80,7 +80,7 @@ impl fmt::Debug for ExtendedPrivKey {
/// Extended public key
#[derive(Copy, Clone, PartialEq, Eq, Debug, PartialOrd, Ord, Hash)]
pub struct ExtendedPubKey {
pub struct Xpub {
/// The network this key is to be used on
pub network: Network,
/// How many derivations this key is from the master (which is 0)
@ -95,7 +95,7 @@ pub struct ExtendedPubKey {
pub chain_code: ChainCode,
}
#[cfg(feature = "serde")]
crate::serde_utils::serde_string_impl!(ExtendedPubKey, "a BIP-32 extended public key");
crate::serde_utils::serde_string_impl!(Xpub, "a BIP-32 extended public key");
/// A child number for a derived key
#[derive(Copy, Clone, PartialEq, Eq, Debug, PartialOrd, Ord, Hash)]
@ -535,14 +535,14 @@ impl From<base58::Error> for Error {
fn from(err: base58::Error) -> Self { Error::Base58(err) }
}
impl ExtendedPrivKey {
impl Xpriv {
/// Construct a new master key from a seed value
pub fn new_master(network: Network, seed: &[u8]) -> Result<ExtendedPrivKey, Error> {
pub fn new_master(network: Network, seed: &[u8]) -> Result<Xpriv, Error> {
let mut hmac_engine: HmacEngine<sha512::Hash> = HmacEngine::new(b"Bitcoin seed");
hmac_engine.input(seed);
let hmac_result: Hmac<sha512::Hash> = Hmac::from_engine(hmac_engine);
Ok(ExtendedPrivKey {
Ok(Xpriv {
network,
depth: 0,
parent_fingerprint: Default::default(),
@ -571,8 +571,8 @@ impl ExtendedPrivKey {
&self,
secp: &Secp256k1<C>,
path: &P,
) -> Result<ExtendedPrivKey, Error> {
let mut sk: ExtendedPrivKey = *self;
) -> Result<Xpriv, Error> {
let mut sk: Xpriv = *self;
for cnum in path.as_ref() {
sk = sk.ckd_priv(secp, *cnum)?;
}
@ -584,7 +584,7 @@ impl ExtendedPrivKey {
&self,
secp: &Secp256k1<C>,
i: ChildNumber,
) -> Result<ExtendedPrivKey, Error> {
) -> Result<Xpriv, Error> {
let mut hmac_engine: HmacEngine<sha512::Hash> = HmacEngine::new(&self.chain_code[..]);
match i {
ChildNumber::Normal { .. } => {
@ -607,7 +607,7 @@ impl ExtendedPrivKey {
let tweaked =
sk.add_tweak(&self.private_key.into()).expect("statistically impossible to hit");
Ok(ExtendedPrivKey {
Ok(Xpriv {
network: self.network,
depth: self.depth + 1,
parent_fingerprint: self.fingerprint(secp),
@ -618,7 +618,7 @@ impl ExtendedPrivKey {
}
/// Decoding extended private key from binary data according to BIP 32
pub fn decode(data: &[u8]) -> Result<ExtendedPrivKey, Error> {
pub fn decode(data: &[u8]) -> Result<Xpriv, Error> {
if data.len() != 78 {
return Err(Error::WrongExtendedKeyLength(data.len()));
}
@ -630,7 +630,7 @@ impl ExtendedPrivKey {
_ => unreachable!("length checked above"),
};
Ok(ExtendedPrivKey {
Ok(Xpriv {
network,
depth: data[4],
parent_fingerprint: data[5..9]
@ -664,7 +664,7 @@ impl ExtendedPrivKey {
/// Returns the HASH160 of the public key belonging to the xpriv
pub fn identifier<C: secp256k1::Signing>(&self, secp: &Secp256k1<C>) -> XpubIdentifier {
ExtendedPubKey::from_priv(secp, self).identifier()
Xpub::from_priv(secp, self).identifier()
}
/// Returns the first four bytes of the identifier
@ -673,13 +673,10 @@ impl ExtendedPrivKey {
}
}
impl ExtendedPubKey {
impl Xpub {
/// Derives a public key from a private key
pub fn from_priv<C: secp256k1::Signing>(
secp: &Secp256k1<C>,
sk: &ExtendedPrivKey,
) -> ExtendedPubKey {
ExtendedPubKey {
pub fn from_priv<C: secp256k1::Signing>(secp: &Secp256k1<C>, sk: &Xpriv) -> Xpub {
Xpub {
network: sk.network,
depth: sk.depth,
parent_fingerprint: sk.parent_fingerprint,
@ -703,8 +700,8 @@ impl ExtendedPubKey {
&self,
secp: &Secp256k1<C>,
path: &P,
) -> Result<ExtendedPubKey, Error> {
let mut pk: ExtendedPubKey = *self;
) -> Result<Xpub, Error> {
let mut pk: Xpub = *self;
for cnum in path.as_ref() {
pk = pk.ckd_pub(secp, *cnum)?
}
@ -738,11 +735,11 @@ impl ExtendedPubKey {
&self,
secp: &Secp256k1<C>,
i: ChildNumber,
) -> Result<ExtendedPubKey, Error> {
) -> Result<Xpub, Error> {
let (sk, chain_code) = self.ckd_pub_tweak(i)?;
let tweaked = self.public_key.add_exp_tweak(secp, &sk.into())?;
Ok(ExtendedPubKey {
Ok(Xpub {
network: self.network,
depth: self.depth + 1,
parent_fingerprint: self.fingerprint(),
@ -753,7 +750,7 @@ impl ExtendedPubKey {
}
/// Decoding extended public key from binary data according to BIP 32
pub fn decode(data: &[u8]) -> Result<ExtendedPubKey, Error> {
pub fn decode(data: &[u8]) -> Result<Xpub, Error> {
if data.len() != 78 {
return Err(Error::WrongExtendedKeyLength(data.len()));
}
@ -765,7 +762,7 @@ impl ExtendedPubKey {
_ => unreachable!("length checked above"),
};
Ok(ExtendedPubKey {
Ok(Xpub {
network,
depth: data[4],
parent_fingerprint: data[5..9]
@ -809,52 +806,52 @@ impl ExtendedPubKey {
}
}
impl fmt::Display for ExtendedPrivKey {
impl fmt::Display for Xpriv {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
base58::encode_check_to_fmt(fmt, &self.encode()[..])
}
}
impl FromStr for ExtendedPrivKey {
impl FromStr for Xpriv {
type Err = Error;
fn from_str(inp: &str) -> Result<ExtendedPrivKey, Error> {
fn from_str(inp: &str) -> Result<Xpriv, Error> {
let data = base58::decode_check(inp)?;
if data.len() != 78 {
return Err(base58::Error::InvalidLength(data.len()).into());
}
ExtendedPrivKey::decode(&data)
Xpriv::decode(&data)
}
}
impl fmt::Display for ExtendedPubKey {
impl fmt::Display for Xpub {
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
base58::encode_check_to_fmt(fmt, &self.encode()[..])
}
}
impl FromStr for ExtendedPubKey {
impl FromStr for Xpub {
type Err = Error;
fn from_str(inp: &str) -> Result<ExtendedPubKey, Error> {
fn from_str(inp: &str) -> Result<Xpub, Error> {
let data = base58::decode_check(inp)?;
if data.len() != 78 {
return Err(base58::Error::InvalidLength(data.len()).into());
}
ExtendedPubKey::decode(&data)
Xpub::decode(&data)
}
}
impl From<ExtendedPubKey> for XpubIdentifier {
fn from(key: ExtendedPubKey) -> XpubIdentifier { key.identifier() }
impl From<Xpub> for XpubIdentifier {
fn from(key: Xpub) -> XpubIdentifier { key.identifier() }
}
impl From<&ExtendedPubKey> for XpubIdentifier {
fn from(key: &ExtendedPubKey) -> XpubIdentifier { key.identifier() }
impl From<&Xpub> for XpubIdentifier {
fn from(key: &Xpub) -> XpubIdentifier { key.identifier() }
}
#[cfg(test)]
@ -953,13 +950,13 @@ mod tests {
expected_sk: &str,
expected_pk: &str,
) {
let mut sk = ExtendedPrivKey::new_master(network, seed).unwrap();
let mut pk = ExtendedPubKey::from_priv(secp, &sk);
let mut sk = Xpriv::new_master(network, seed).unwrap();
let mut pk = Xpub::from_priv(secp, &sk);
// Check derivation convenience method for ExtendedPrivKey
// Check derivation convenience method for Xpriv
assert_eq!(&sk.derive_priv(secp, &path).unwrap().to_string()[..], expected_sk);
// Check derivation convenience method for ExtendedPubKey, should error
// Check derivation convenience method for Xpub, should error
// appropriately if any ChildNumber is hardened
if path.0.iter().any(|cnum| cnum.is_hardened()) {
assert_eq!(pk.derive_pub(secp, &path), Err(Error::CannotDeriveFromHardenedKey));
@ -973,12 +970,12 @@ mod tests {
match num {
Normal { .. } => {
let pk2 = pk.ckd_pub(secp, num).unwrap();
pk = ExtendedPubKey::from_priv(secp, &sk);
pk = Xpub::from_priv(secp, &sk);
assert_eq!(pk, pk2);
}
Hardened { .. } => {
assert_eq!(pk.ckd_pub(secp, num), Err(Error::CannotDeriveFromHardenedKey));
pk = ExtendedPubKey::from_priv(secp, &sk);
pk = Xpub::from_priv(secp, &sk);
}
}
}
@ -987,8 +984,8 @@ mod tests {
assert_eq!(&sk.to_string()[..], expected_sk);
assert_eq!(&pk.to_string()[..], expected_pk);
// Check decoded base58 against result
let decoded_sk = ExtendedPrivKey::from_str(expected_sk);
let decoded_pk = ExtendedPubKey::from_str(expected_pk);
let decoded_sk = Xpriv::from_str(expected_sk);
let decoded_pk = Xpub::from_str(expected_pk);
assert_eq!(Ok(sk), decoded_sk);
assert_eq!(Ok(pk), decoded_pk);
}
@ -1181,7 +1178,7 @@ mod tests {
sk.as_mut_ptr().copy_from(zeros.as_ptr(), 32);
}
let xpriv = ExtendedPrivKey {
let xpriv = Xpriv {
network: Network::Bitcoin,
depth: 0,
parent_fingerprint: Default::default(),
@ -1195,7 +1192,7 @@ mod tests {
// Xpriv having secret key set to all zeros
let xpriv_str = "xprv9s21ZrQH143K24Mfq5zL5MhWK9hUhhGbd45hLXo2Pq2oqzMMo63oStZzF93Y5wvzdUayhgkkFoicQZcP3y52uPPxFnfoLZB21Teqt1VvEHx";
ExtendedPrivKey::from_str(xpriv_str).unwrap();
Xpriv::from_str(xpriv_str).unwrap();
}
#[test]
@ -1203,6 +1200,6 @@ mod tests {
fn schnorr_broken_privkey_ffs() {
// Xpriv having secret key set to all 0xFF's
let xpriv_str = "xprv9s21ZrQH143K24Mfq5zL5MhWK9hUhhGbd45hLXo2Pq2oqzMMo63oStZzFAzHGBP2UuGCqWLTAPLcMtD9y5gkZ6Eq3Rjuahrv17fENZ3QzxW";
ExtendedPrivKey::from_str(xpriv_str).unwrap();
Xpriv::from_str(xpriv_str).unwrap();
}
}

4
bitcoin/src/psbt/error.rs
View File

@ -4,7 +4,7 @@ use core::fmt;
use internals::write_err;
use crate::bip32::ExtendedPubKey;
use crate::bip32::Xpub;
use crate::blockdata::transaction::Transaction;
use crate::consensus::encode;
use crate::prelude::*;
@ -69,7 +69,7 @@ pub enum Error {
},
/// Conflicting data during combine procedure:
/// global extended public key has inconsistent key sources
CombineInconsistentKeySources(Box<ExtendedPubKey>),
CombineInconsistentKeySources(Box<Xpub>),
/// Serialization error in bitcoin consensus-encoded structures
ConsensusEncoding(encode::Error),
/// Negative fee

7
bitcoin/src/psbt/map/global.rs
View File

@ -2,7 +2,7 @@
use core::convert::TryFrom;
use crate::bip32::{ChildNumber, DerivationPath, ExtendedPubKey, Fingerprint};
use crate::bip32::{ChildNumber, DerivationPath, Fingerprint, Xpub};
use crate::blockdata::transaction::Transaction;
use crate::consensus::encode::MAX_VEC_SIZE;
use crate::consensus::{encode, Decodable};
@ -76,8 +76,7 @@ impl Psbt {
let mut tx: Option<Transaction> = None;
let mut version: Option<u32> = None;
let mut unknowns: BTreeMap<raw::Key, Vec<u8>> = Default::default();
let mut xpub_map: BTreeMap<ExtendedPubKey, (Fingerprint, DerivationPath)> =
Default::default();
let mut xpub_map: BTreeMap<Xpub, (Fingerprint, DerivationPath)> = Default::default();
let mut proprietary: BTreeMap<raw::ProprietaryKey, Vec<u8>> = Default::default();
loop {
@ -114,7 +113,7 @@ impl Psbt {
}
PSBT_GLOBAL_XPUB => {
if !pair.key.key.is_empty() {
let xpub = ExtendedPubKey::decode(&pair.key.key)
let xpub = Xpub::decode(&pair.key.key)
.map_err(|_| Error::XPubKey(
"Can't deserialize ExtendedPublicKey from global XPUB key data"
))?;

16
bitcoin/src/psbt/mod.rs
View File

@ -15,7 +15,7 @@ use hashes::Hash;
use internals::write_err;
use secp256k1::{Message, Secp256k1, Signing};
use crate::bip32::{self, ExtendedPrivKey, ExtendedPubKey, KeySource};
use crate::bip32::{self, KeySource, Xpriv, Xpub};
use crate::blockdata::transaction::{Transaction, TxOut};
use crate::crypto::ecdsa;
use crate::crypto::key::{PrivateKey, PublicKey};
@ -45,7 +45,7 @@ pub struct Psbt {
pub version: u32,
/// A global map from extended public keys to the used key fingerprint and
/// derivation path as defined by BIP 32.
pub xpub: BTreeMap<ExtendedPubKey, KeySource>,
pub xpub: BTreeMap<Xpub, KeySource>,
/// Global proprietary key-value pairs.
#[cfg_attr(feature = "serde", serde(with = "crate::serde_utils::btreemap_as_seq_byte_values"))]
pub proprietary: BTreeMap<raw::ProprietaryKey, Vec<u8>>,
@ -508,7 +508,7 @@ pub trait GetKey {
) -> Result<Option<PrivateKey>, Self::Error>;
}
impl GetKey for ExtendedPrivKey {
impl GetKey for Xpriv {
type Error = GetKeyError;
fn get_key<C: Signing>(
@ -541,7 +541,7 @@ pub type SigningErrors = BTreeMap<usize, SignError>;
macro_rules! impl_get_key_for_set {
($set:ident) => {
impl GetKey for $set<ExtendedPrivKey> {
impl GetKey for $set<Xpriv> {
type Error = GetKeyError;
fn get_key<C: Signing>(
@ -831,7 +831,7 @@ mod tests {
use secp256k1::{All, SecretKey};
use super::*;
use crate::bip32::{ChildNumber, ExtendedPrivKey, ExtendedPubKey, KeySource};
use crate::bip32::{ChildNumber, KeySource, Xpriv, Xpub};
use crate::blockdata::locktime::absolute;
use crate::blockdata::script::ScriptBuf;
use crate::blockdata::transaction::{OutPoint, Sequence, Transaction, TxIn, TxOut};
@ -878,7 +878,7 @@ mod tests {
let mut hd_keypaths: BTreeMap<secp256k1::PublicKey, KeySource> = Default::default();
let mut sk: ExtendedPrivKey = ExtendedPrivKey::new_master(Bitcoin, &seed).unwrap();
let mut sk: Xpriv = Xpriv::new_master(Bitcoin, &seed).unwrap();
let fprint = sk.fingerprint(secp);
@ -895,7 +895,7 @@ mod tests {
sk = sk.derive_priv(secp, &dpath).unwrap();
let pk = ExtendedPubKey::from_priv(secp, &sk);
let pk = Xpub::from_priv(secp, &sk);
hd_keypaths.insert(pk.public_key, (fprint, dpath.into()));
@ -1040,7 +1040,7 @@ mod tests {
let psbt = Psbt {
version: 0,
xpub: {
let xpub: ExtendedPubKey =
let xpub: Xpub =
"xpub661MyMwAqRbcGoRVtwfvzZsq2VBJR1LAHfQstHUoxqDorV89vRoMxUZ27kLrraAj6MPi\
QfrDb27gigC1VS1dBXi5jGpxmMeBXEkKkcXUTg4".parse().unwrap();
vec![(xpub, key_source)].into_iter().collect()

14
bitcoin/tests/psbt.rs
View File

@ -5,7 +5,7 @@ use core::convert::TryFrom;
use std::collections::BTreeMap;
use std::str::FromStr;
use bitcoin::bip32::{ExtendedPrivKey, ExtendedPubKey, Fingerprint, IntoDerivationPath, KeySource};
use bitcoin::bip32::{Fingerprint, IntoDerivationPath, KeySource, Xpriv, Xpub};
use bitcoin::blockdata::opcodes::OP_0;
use bitcoin::blockdata::script;
use bitcoin::consensus::encode::{deserialize, serialize_hex};
@ -41,7 +41,7 @@ fn bip174_psbt_workflow() {
//
let ext_priv = build_extended_private_key();
let ext_pub = ExtendedPubKey::from_priv(&secp, &ext_priv);
let ext_pub = Xpub::from_priv(&secp, &ext_priv);
let parent_fingerprint = ext_pub.fingerprint();
//
@ -120,15 +120,15 @@ fn bip174_psbt_workflow() {
}
/// Attempts to build an extended private key from seed and also directly from a string.
fn build_extended_private_key() -> ExtendedPrivKey {
fn build_extended_private_key() -> Xpriv {
// Strings from BIP 174 test vector.
let extended_private_key = "tprv8ZgxMBicQKsPd9TeAdPADNnSyH9SSUUbTVeFszDE23Ki6TBB5nCefAdHkK8Fm3qMQR6sHwA56zqRmKmxnHk37JkiFzvncDqoKmPWubu7hDF";
let seed = "cUkG8i1RFfWGWy5ziR11zJ5V4U4W3viSFCfyJmZnvQaUsd1xuF3T";
let xpriv = ExtendedPrivKey::from_str(extended_private_key).unwrap();
let xpriv = Xpriv::from_str(extended_private_key).unwrap();
let sk = PrivateKey::from_wif(seed).unwrap();
let seeded = ExtendedPrivKey::new_master(NETWORK, &sk.inner.secret_bytes()).unwrap();
let seeded = Xpriv::new_master(NETWORK, &sk.inner.secret_bytes()).unwrap();
assert_eq!(xpriv, seeded);
xpriv
@ -224,7 +224,7 @@ fn update_psbt(mut psbt: Psbt, fingerprint: Fingerprint) -> Psbt {
let redeem_script_1 = "00208c2353173743b595dfb4a07b72ba8e42e3797da74e87fe7d9d7497e3b2028903";
let witness_script = "522103089dc10c7ac6db54f91329af617333db388cead0c231f723379d1b99030b02dc21023add904f3d6dcf59ddb906b0dee23529b7ffb9ed50e5e86151926860221f0e7352ae";
// Public key and its derivation path (these are the child pubkeys for our `ExtendedPrivKey`,
// Public key and its derivation path (these are the child pubkeys for our `Xpriv`,
// can be verified by deriving the key using this derivation path).
let pk_path = vec![
("029583bf39ae0a609747ad199addd634fa6108559d6c5cd39b4c2183f1ab96e07f", "m/0h/0h/0h"),
@ -310,7 +310,7 @@ fn update_psbt_with_sighash_all(mut psbt: Psbt) -> Psbt {
/// Verifies the keys in the test vector are valid for the extended private key and derivation path.
fn parse_and_verify_keys(
ext_priv: &ExtendedPrivKey,
ext_priv: &Xpriv,
sk_path: &[(&str, &str)],
) -> BTreeMap<PublicKey, PrivateKey> {
let secp = &Secp256k1::new();

8
bitcoin/tests/serde.rs
View File

@ -27,7 +27,7 @@ use std::convert::TryFrom;
use std::str::FromStr;
use bincode::serialize;
use bitcoin::bip32::{ChildNumber, ExtendedPrivKey, ExtendedPubKey, KeySource};
use bitcoin::bip32::{ChildNumber, KeySource, Xpriv, Xpub};
use bitcoin::blockdata::locktime::{absolute, relative};
use bitcoin::blockdata::witness::Witness;
use bitcoin::consensus::encode::deserialize;
@ -155,7 +155,7 @@ fn serde_regression_address() {
#[test]
fn serde_regression_extended_priv_key() {
let s = include_str!("data/serde/extended_priv_key");
let key = ExtendedPrivKey::from_str(s.trim()).unwrap();
let key = Xpriv::from_str(s.trim()).unwrap();
let got = serialize(&key).unwrap();
let want = include_bytes!("data/serde/extended_priv_key_bincode") as &[_];
assert_eq!(got, want)
@ -164,7 +164,7 @@ fn serde_regression_extended_priv_key() {
#[test]
fn serde_regression_extended_pub_key() {
let s = include_str!("data/serde/extended_pub_key");
let key = ExtendedPubKey::from_str(s.trim()).unwrap();
let key = Xpub::from_str(s.trim()).unwrap();
let got = serialize(&key).unwrap();
let want = include_bytes!("data/serde/extended_pub_key_bincode") as &[_];
assert_eq!(got, want)
@ -269,7 +269,7 @@ fn serde_regression_psbt() {
version: 0,
xpub: {
let s = include_str!("data/serde/extended_pub_key");
let xpub = ExtendedPubKey::from_str(s.trim()).unwrap();
let xpub = Xpub::from_str(s.trim()).unwrap();
vec![(xpub, key_source)].into_iter().collect()
},
unsigned_tx: {