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

Change T::from_str(s) to s.parse::<T>() in tests 

`s.parse` is more idiomatic and produces more helpful error messages.

This has been changed repo wide in tests.
This commit is contained in:
Jamil Lambert, PhD 2024-08-28 16:13:03 +01:00
parent 4ad86148c7
commit 9fce57b738
No known key found for this signature in database
GPG Key ID: 54DC29234AB5D2C0
21 changed files with 269 additions and 289 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
bitcoin/examples/ecdsa-psbt-simple.rs
View File

@ -84,7 +84,8 @@ fn get_internal_address_xpriv<C: Signing>(
// The address to send to. // The address to send to.
fn receivers_address() -> Address { fn receivers_address() -> Address {
"bc1q7cyrfmck2ffu2ud3rn5l5a8yv6f0chkp0zpemf".parse::<Address<_>>() "bc1q7cyrfmck2ffu2ud3rn5l5a8yv6f0chkp0zpemf"
.parse::<Address<_>>()
.expect("a valid address") .expect("a valid address")
.require_network(Network::Bitcoin) .require_network(Network::Bitcoin)
.expect("valid address for mainnet") .expect("valid address for mainnet")
@ -92,7 +93,8 @@ fn receivers_address() -> Address {
// The dummy unspent transaction outputs that we control. // The dummy unspent transaction outputs that we control.
fn dummy_unspent_transaction_outputs() -> Vec<(OutPoint, TxOut)> { fn dummy_unspent_transaction_outputs() -> Vec<(OutPoint, TxOut)> {
let script_pubkey_1 = "bc1qrwuu3ydv0jfza4a0ehtfd03m9l4vw3fy0hfm50".parse::<Address<_>>() let script_pubkey_1 = "bc1qrwuu3ydv0jfza4a0ehtfd03m9l4vw3fy0hfm50"
.parse::<Address<_>>()
.expect("a valid address") .expect("a valid address")
.require_network(Network::Bitcoin) .require_network(Network::Bitcoin)
.expect("valid address for mainnet") .expect("valid address for mainnet")
@ -105,7 +107,8 @@ fn dummy_unspent_transaction_outputs() -> Vec<(OutPoint, TxOut)> {
let utxo_1 = TxOut { value: DUMMY_UTXO_AMOUNT_INPUT_1, script_pubkey: script_pubkey_1 }; let utxo_1 = TxOut { value: DUMMY_UTXO_AMOUNT_INPUT_1, script_pubkey: script_pubkey_1 };
let script_pubkey_2 = "bc1qy7swwpejlw7a2rp774pa8rymh8tw3xvd2x2xkd".parse::<Address<_>>() let script_pubkey_2 = "bc1qy7swwpejlw7a2rp774pa8rymh8tw3xvd2x2xkd"
.parse::<Address<_>>()
.expect("a valid address") .expect("a valid address")
.require_network(Network::Bitcoin) .require_network(Network::Bitcoin)
.expect("valid address for mainnet") .expect("valid address for mainnet")

120
bitcoin/src/address/mod.rs
View File

@ -898,7 +898,7 @@ mod tests {
fn roundtrips(addr: &Address, network: Network) { fn roundtrips(addr: &Address, network: Network) {
assert_eq!( assert_eq!(
Address::from_str(&addr.to_string()).unwrap().assume_checked(), addr.to_string().parse::<Address<_>>().unwrap().assume_checked(),
*addr, *addr,
"string round-trip failed for {}", "string round-trip failed for {}",
addr, addr,
@ -1051,7 +1051,7 @@ mod tests {
} }
let addr_str = "33iFwdLuRpW1uK1RTRqsoi8rR4NpDzk66k"; let addr_str = "33iFwdLuRpW1uK1RTRqsoi8rR4NpDzk66k";
let unchecked = Address::from_str(addr_str).unwrap(); let unchecked = addr_str.parse::<Address<_>>().unwrap();
assert_eq!( assert_eq!(
format!("{:?}", Test { address: unchecked.clone() }), format!("{:?}", Test { address: unchecked.clone() }),
@ -1085,7 +1085,8 @@ mod tests {
("bc1zw508d6qejxtdg4y5r3zarvaryvaxxpcs", None), ("bc1zw508d6qejxtdg4y5r3zarvaryvaxxpcs", None),
]; ];
for (address, expected_type) in &addresses { for (address, expected_type) in &addresses {
let addr = Address::from_str(address) let addr = address
.parse::<Address<_>>()
.unwrap() .unwrap()
.require_network(Network::Bitcoin) .require_network(Network::Bitcoin)
.expect("mainnet"); .expect("mainnet");
@ -1099,7 +1100,7 @@ mod tests {
use serde_json; use serde_json;
let addr = let addr =
Address::from_str("132F25rTsvBdp9JzLLBHP5mvGY66i1xdiM").unwrap().assume_checked(); "132F25rTsvBdp9JzLLBHP5mvGY66i1xdiM".parse::<Address<_>>().unwrap().assume_checked();
let json = serde_json::to_value(&addr).unwrap(); let json = serde_json::to_value(&addr).unwrap();
assert_eq!( assert_eq!(
json, json,
@ -1113,7 +1114,7 @@ mod tests {
); );
let addr = let addr =
Address::from_str("33iFwdLuRpW1uK1RTRqsoi8rR4NpDzk66k").unwrap().assume_checked(); "33iFwdLuRpW1uK1RTRqsoi8rR4NpDzk66k".parse::<Address<_>>().unwrap().assume_checked();
let json = serde_json::to_value(&addr).unwrap(); let json = serde_json::to_value(&addr).unwrap();
assert_eq!( assert_eq!(
json, json,
@ -1127,7 +1128,8 @@ mod tests {
); );
let addr: Address<NetworkUnchecked> = let addr: Address<NetworkUnchecked> =
Address::from_str("tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k7") "tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k7"
.parse::<Address<_>>()
.unwrap(); .unwrap();
let json = serde_json::to_value(addr).unwrap(); let json = serde_json::to_value(addr).unwrap();
assert_eq!( assert_eq!(
@ -1137,10 +1139,10 @@ mod tests {
) )
); );
let addr = let addr = "tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k7"
Address::from_str("tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k7") .parse::<Address<_>>()
.unwrap() .unwrap()
.assume_checked(); .assume_checked();
let json = serde_json::to_value(&addr).unwrap(); let json = serde_json::to_value(&addr).unwrap();
assert_eq!( assert_eq!(
json, json,
@ -1158,7 +1160,8 @@ mod tests {
.unwrap() .unwrap()
); );
let addr = Address::from_str("bcrt1q2nfxmhd4n3c8834pj72xagvyr9gl57n5r94fsl") let addr = "bcrt1q2nfxmhd4n3c8834pj72xagvyr9gl57n5r94fsl"
.parse::<Address<_>>()
.unwrap() .unwrap()
.assume_checked(); .assume_checked();
let json = serde_json::to_value(&addr).unwrap(); let json = serde_json::to_value(&addr).unwrap();
@ -1179,8 +1182,11 @@ mod tests {
for el in for el in
["132F25rTsvBdp9JzLLBHP5mvGY66i1xdiM", "33iFwdLuRpW1uK1RTRqsoi8rR4NpDzk66k"].iter() ["132F25rTsvBdp9JzLLBHP5mvGY66i1xdiM", "33iFwdLuRpW1uK1RTRqsoi8rR4NpDzk66k"].iter()
{ {
let addr = let addr = el
Address::from_str(el).unwrap().require_network(Network::Bitcoin).expect("mainnet"); .parse::<Address<_>>()
.unwrap()
.require_network(Network::Bitcoin)
.expect("mainnet");
assert_eq!(addr.to_qr_uri(), format!("bitcoin:{}", el)); assert_eq!(addr.to_qr_uri(), format!("bitcoin:{}", el));
} }
@ -1190,7 +1196,7 @@ mod tests {
] ]
.iter() .iter()
{ {
let addr = Address::from_str(el).unwrap().assume_checked(); let addr = el.parse::<Address<_>>().unwrap().assume_checked();
assert_eq!(addr.to_qr_uri(), format!("bitcoin:{}", el.to_ascii_uppercase())); assert_eq!(addr.to_qr_uri(), format!("bitcoin:{}", el.to_ascii_uppercase()));
} }
} }
@ -1198,10 +1204,9 @@ mod tests {
#[test] #[test]
fn p2tr_from_untweaked() { fn p2tr_from_untweaked() {
//Test case from BIP-086 //Test case from BIP-086
let internal_key = XOnlyPublicKey::from_str( let internal_key = "cc8a4bc64d897bddc5fbc2f670f7a8ba0b386779106cf1223c6fc5d7cd6fc115"
"cc8a4bc64d897bddc5fbc2f670f7a8ba0b386779106cf1223c6fc5d7cd6fc115", .parse::<XOnlyPublicKey>()
) .unwrap();
.unwrap();
let secp = Secp256k1::verification_only(); let secp = Secp256k1::verification_only();
let address = Address::p2tr(&secp, internal_key, None, KnownHrp::Mainnet); let address = Address::p2tr(&secp, internal_key, None, KnownHrp::Mainnet);
assert_eq!( assert_eq!(
@ -1215,98 +1220,99 @@ mod tests {
#[test] #[test]
fn test_is_related_to_pubkey_p2wpkh() { fn test_is_related_to_pubkey_p2wpkh() {
let address_string = "bc1qhvd6suvqzjcu9pxjhrwhtrlj85ny3n2mqql5w4"; let address_string = "bc1qhvd6suvqzjcu9pxjhrwhtrlj85ny3n2mqql5w4";
let address = Address::from_str(address_string) let address = address_string
.parse::<Address<_>>()
.expect("address") .expect("address")
.require_network(Network::Bitcoin) .require_network(Network::Bitcoin)
.expect("mainnet"); .expect("mainnet");
let pubkey_string = "0347ff3dacd07a1f43805ec6808e801505a6e18245178609972a68afbc2777ff2b"; let pubkey_string = "0347ff3dacd07a1f43805ec6808e801505a6e18245178609972a68afbc2777ff2b";
let pubkey = PublicKey::from_str(pubkey_string).expect("pubkey"); let pubkey = pubkey_string.parse::<PublicKey>().expect("pubkey");
let result = address.is_related_to_pubkey(pubkey); let result = address.is_related_to_pubkey(pubkey);
assert!(result); assert!(result);
let unused_pubkey = PublicKey::from_str( let unused_pubkey = "02ba604e6ad9d3864eda8dc41c62668514ef7d5417d3b6db46e45cc4533bff001c"
"02ba604e6ad9d3864eda8dc41c62668514ef7d5417d3b6db46e45cc4533bff001c", .parse::<PublicKey>()
) .expect("pubkey");
.expect("pubkey");
assert!(!address.is_related_to_pubkey(unused_pubkey)) assert!(!address.is_related_to_pubkey(unused_pubkey))
} }
#[test] #[test]
fn test_is_related_to_pubkey_p2shwpkh() { fn test_is_related_to_pubkey_p2shwpkh() {
let address_string = "3EZQk4F8GURH5sqVMLTFisD17yNeKa7Dfs"; let address_string = "3EZQk4F8GURH5sqVMLTFisD17yNeKa7Dfs";
let address = Address::from_str(address_string) let address = address_string
.parse::<Address<_>>()
.expect("address") .expect("address")
.require_network(Network::Bitcoin) .require_network(Network::Bitcoin)
.expect("mainnet"); .expect("mainnet");
let pubkey_string = "0347ff3dacd07a1f43805ec6808e801505a6e18245178609972a68afbc2777ff2b"; let pubkey_string = "0347ff3dacd07a1f43805ec6808e801505a6e18245178609972a68afbc2777ff2b";
let pubkey = PublicKey::from_str(pubkey_string).expect("pubkey"); let pubkey = pubkey_string.parse::<PublicKey>().expect("pubkey");
let result = address.is_related_to_pubkey(pubkey); let result = address.is_related_to_pubkey(pubkey);
assert!(result); assert!(result);
let unused_pubkey = PublicKey::from_str( let unused_pubkey = "02ba604e6ad9d3864eda8dc41c62668514ef7d5417d3b6db46e45cc4533bff001c"
"02ba604e6ad9d3864eda8dc41c62668514ef7d5417d3b6db46e45cc4533bff001c", .parse::<PublicKey>()
) .expect("pubkey");
.expect("pubkey");
assert!(!address.is_related_to_pubkey(unused_pubkey)) assert!(!address.is_related_to_pubkey(unused_pubkey))
} }
#[test] #[test]
fn test_is_related_to_pubkey_p2pkh() { fn test_is_related_to_pubkey_p2pkh() {
let address_string = "1J4LVanjHMu3JkXbVrahNuQCTGCRRgfWWx"; let address_string = "1J4LVanjHMu3JkXbVrahNuQCTGCRRgfWWx";
let address = Address::from_str(address_string) let address = address_string
.parse::<Address<_>>()
.expect("address") .expect("address")
.require_network(Network::Bitcoin) .require_network(Network::Bitcoin)
.expect("mainnet"); .expect("mainnet");
let pubkey_string = "0347ff3dacd07a1f43805ec6808e801505a6e18245178609972a68afbc2777ff2b"; let pubkey_string = "0347ff3dacd07a1f43805ec6808e801505a6e18245178609972a68afbc2777ff2b";
let pubkey = PublicKey::from_str(pubkey_string).expect("pubkey"); let pubkey = pubkey_string.parse::<PublicKey>().expect("pubkey");
let result = address.is_related_to_pubkey(pubkey); let result = address.is_related_to_pubkey(pubkey);
assert!(result); assert!(result);
let unused_pubkey = PublicKey::from_str( let unused_pubkey = "02ba604e6ad9d3864eda8dc41c62668514ef7d5417d3b6db46e45cc4533bff001c"
"02ba604e6ad9d3864eda8dc41c62668514ef7d5417d3b6db46e45cc4533bff001c", .parse::<PublicKey>()
) .expect("pubkey");
.expect("pubkey");
assert!(!address.is_related_to_pubkey(unused_pubkey)) assert!(!address.is_related_to_pubkey(unused_pubkey))
} }
#[test] #[test]
fn test_is_related_to_pubkey_p2pkh_uncompressed_key() { fn test_is_related_to_pubkey_p2pkh_uncompressed_key() {
let address_string = "msvS7KzhReCDpQEJaV2hmGNvuQqVUDuC6p"; let address_string = "msvS7KzhReCDpQEJaV2hmGNvuQqVUDuC6p";
let address = Address::from_str(address_string) let address = address_string
.parse::<Address<_>>()
.expect("address") .expect("address")
.require_network(Network::Testnet) .require_network(Network::Testnet)
.expect("testnet"); .expect("testnet");
let pubkey_string = "04e96e22004e3db93530de27ccddfdf1463975d2138ac018fc3e7ba1a2e5e0aad8e424d0b55e2436eb1d0dcd5cb2b8bcc6d53412c22f358de57803a6a655fbbd04"; let pubkey_string = "04e96e22004e3db93530de27ccddfdf1463975d2138ac018fc3e7ba1a2e5e0aad8e424d0b55e2436eb1d0dcd5cb2b8bcc6d53412c22f358de57803a6a655fbbd04";
let pubkey = PublicKey::from_str(pubkey_string).expect("pubkey"); let pubkey = pubkey_string.parse::<PublicKey>().expect("pubkey");
let result = address.is_related_to_pubkey(pubkey); let result = address.is_related_to_pubkey(pubkey);
assert!(result); assert!(result);
let unused_pubkey = PublicKey::from_str( let unused_pubkey = "02ba604e6ad9d3864eda8dc41c62668514ef7d5417d3b6db46e45cc4533bff001c"
"02ba604e6ad9d3864eda8dc41c62668514ef7d5417d3b6db46e45cc4533bff001c", .parse::<PublicKey>()
) .expect("pubkey");
.expect("pubkey");
assert!(!address.is_related_to_pubkey(unused_pubkey)) assert!(!address.is_related_to_pubkey(unused_pubkey))
} }
#[test] #[test]
fn test_is_related_to_pubkey_p2tr() { fn test_is_related_to_pubkey_p2tr() {
let pubkey_string = "0347ff3dacd07a1f43805ec6808e801505a6e18245178609972a68afbc2777ff2b"; let pubkey_string = "0347ff3dacd07a1f43805ec6808e801505a6e18245178609972a68afbc2777ff2b";
let pubkey = PublicKey::from_str(pubkey_string).expect("pubkey"); let pubkey = pubkey_string.parse::<PublicKey>().expect("pubkey");
let xonly_pubkey = XOnlyPublicKey::from(pubkey.inner); let xonly_pubkey = XOnlyPublicKey::from(pubkey.inner);
let tweaked_pubkey = TweakedPublicKey::dangerous_assume_tweaked(xonly_pubkey); let tweaked_pubkey = TweakedPublicKey::dangerous_assume_tweaked(xonly_pubkey);
let address = Address::p2tr_tweaked(tweaked_pubkey, KnownHrp::Mainnet); let address = Address::p2tr_tweaked(tweaked_pubkey, KnownHrp::Mainnet);
assert_eq!( assert_eq!(
address, address,
Address::from_str("bc1pgllnmtxs0g058qz7c6qgaqq4qknwrqj9z7rqn9e2dzhmcfmhlu4sfadf5e") "bc1pgllnmtxs0g058qz7c6qgaqq4qknwrqj9z7rqn9e2dzhmcfmhlu4sfadf5e"
.parse::<Address<_>>()
.expect("address") .expect("address")
.require_network(Network::Bitcoin) .require_network(Network::Bitcoin)
.expect("mainnet") .expect("mainnet")
@ -1315,24 +1321,24 @@ mod tests {
let result = address.is_related_to_pubkey(pubkey); let result = address.is_related_to_pubkey(pubkey);
assert!(result); assert!(result);
let unused_pubkey = PublicKey::from_str( let unused_pubkey = "02ba604e6ad9d3864eda8dc41c62668514ef7d5417d3b6db46e45cc4533bff001c"
"02ba604e6ad9d3864eda8dc41c62668514ef7d5417d3b6db46e45cc4533bff001c", .parse::<PublicKey>()
) .expect("pubkey");
.expect("pubkey");
assert!(!address.is_related_to_pubkey(unused_pubkey)); assert!(!address.is_related_to_pubkey(unused_pubkey));
} }
#[test] #[test]
fn test_is_related_to_xonly_pubkey() { fn test_is_related_to_xonly_pubkey() {
let pubkey_string = "0347ff3dacd07a1f43805ec6808e801505a6e18245178609972a68afbc2777ff2b"; let pubkey_string = "0347ff3dacd07a1f43805ec6808e801505a6e18245178609972a68afbc2777ff2b";
let pubkey = PublicKey::from_str(pubkey_string).expect("pubkey"); let pubkey = pubkey_string.parse::<PublicKey>().expect("pubkey");
let xonly_pubkey = XOnlyPublicKey::from(pubkey.inner); let xonly_pubkey = XOnlyPublicKey::from(pubkey.inner);
let tweaked_pubkey = TweakedPublicKey::dangerous_assume_tweaked(xonly_pubkey); let tweaked_pubkey = TweakedPublicKey::dangerous_assume_tweaked(xonly_pubkey);
let address = Address::p2tr_tweaked(tweaked_pubkey, KnownHrp::Mainnet); let address = Address::p2tr_tweaked(tweaked_pubkey, KnownHrp::Mainnet);
assert_eq!( assert_eq!(
address, address,
Address::from_str("bc1pgllnmtxs0g058qz7c6qgaqq4qknwrqj9z7rqn9e2dzhmcfmhlu4sfadf5e") "bc1pgllnmtxs0g058qz7c6qgaqq4qknwrqj9z7rqn9e2dzhmcfmhlu4sfadf5e"
.parse::<Address<_>>()
.expect("address") .expect("address")
.require_network(Network::Bitcoin) .require_network(Network::Bitcoin)
.expect("mainnet") .expect("mainnet")
@ -1365,13 +1371,13 @@ mod tests {
#[test] #[test]
fn valid_address_parses_correctly() { fn valid_address_parses_correctly() {
let addr = AddressType::from_str("p2tr").expect("false negative while parsing address"); let addr = "p2tr".parse::<AddressType>().expect("false negative while parsing address");
assert_eq!(addr, AddressType::P2tr); assert_eq!(addr, AddressType::P2tr);
} }
#[test] #[test]
fn invalid_address_parses_error() { fn invalid_address_parses_error() {
let got = AddressType::from_str("invalid"); let got = "invalid".parse::<AddressType>();
let want = Err(UnknownAddressTypeError("invalid".to_string())); let want = Err(UnknownAddressTypeError("invalid".to_string()));
assert_eq!(got, want); assert_eq!(got, want);
} }
@ -1389,10 +1395,14 @@ mod tests {
"bc1pgllnmtxs0g058qz7c6qgaqq4qknwrqj9z7rqn9e2dzhmcfmhlu4sfadf5e", "bc1pgllnmtxs0g058qz7c6qgaqq4qknwrqj9z7rqn9e2dzhmcfmhlu4sfadf5e",
]; ];
for addr in &addresses { for addr in &addresses {
let addr = Address::from_str(addr).unwrap().require_network(Network::Bitcoin).unwrap(); let addr =
addr.parse::<Address<_>>().unwrap().require_network(Network::Bitcoin).unwrap();
for another in &addresses { for another in &addresses {
let another = let another = another
Address::from_str(another).unwrap().require_network(Network::Bitcoin).unwrap(); .parse::<Address<_>>()
.unwrap()
.require_network(Network::Bitcoin)
.unwrap();
assert_eq!(addr.matches_script_pubkey(&another.script_pubkey()), addr == another); assert_eq!(addr.matches_script_pubkey(&another.script_pubkey()), addr == another);
} }
} }

60
bitcoin/src/bip32.rs
View File

@ -924,30 +924,30 @@ mod tests {
#[test] #[test]
fn test_parse_derivation_path() { fn test_parse_derivation_path() {
assert_eq!(DerivationPath::from_str("n/0'/0"), Err(Error::InvalidChildNumberFormat)); assert_eq!("n/0'/0".parse::<DerivationPath>(), Err(Error::InvalidChildNumberFormat));
assert_eq!(DerivationPath::from_str("4/m/5"), Err(Error::InvalidChildNumberFormat)); assert_eq!("4/m/5".parse::<DerivationPath>(), Err(Error::InvalidChildNumberFormat));
assert_eq!(DerivationPath::from_str("//3/0'"), Err(Error::InvalidChildNumberFormat)); assert_eq!("//3/0'".parse::<DerivationPath>(), Err(Error::InvalidChildNumberFormat));
assert_eq!(DerivationPath::from_str("0h/0x"), Err(Error::InvalidChildNumberFormat)); assert_eq!("0h/0x".parse::<DerivationPath>(), Err(Error::InvalidChildNumberFormat));
assert_eq!( assert_eq!(
DerivationPath::from_str("2147483648"), "2147483648".parse::<DerivationPath>(),
Err(Error::InvalidChildNumber(2147483648)) Err(Error::InvalidChildNumber(2147483648))
); );
assert_eq!(DerivationPath::master(), DerivationPath::from_str("").unwrap()); assert_eq!(DerivationPath::master(), "".parse::<DerivationPath>().unwrap());
assert_eq!(DerivationPath::master(), DerivationPath::default()); assert_eq!(DerivationPath::master(), DerivationPath::default());
// Acceptable forms for a master path. // Acceptable forms for a master path.
assert_eq!(DerivationPath::from_str("m").unwrap(), DerivationPath(vec![])); assert_eq!("m".parse::<DerivationPath>().unwrap(), DerivationPath(vec![]));
assert_eq!(DerivationPath::from_str("m/").unwrap(), DerivationPath(vec![])); assert_eq!("m/".parse::<DerivationPath>().unwrap(), DerivationPath(vec![]));
assert_eq!(DerivationPath::from_str("").unwrap(), DerivationPath(vec![])); assert_eq!("".parse::<DerivationPath>().unwrap(), DerivationPath(vec![]));
assert_eq!(DerivationPath::from_str("0'"), Ok(vec![ChildNumber::ZERO_HARDENED].into())); assert_eq!("0'".parse::<DerivationPath>(), Ok(vec![ChildNumber::ZERO_HARDENED].into()));
assert_eq!( assert_eq!(
DerivationPath::from_str("0'/1"), "0'/1".parse::<DerivationPath>(),
Ok(vec![ChildNumber::ZERO_HARDENED, ChildNumber::ONE_NORMAL].into()) Ok(vec![ChildNumber::ZERO_HARDENED, ChildNumber::ONE_NORMAL].into())
); );
assert_eq!( assert_eq!(
DerivationPath::from_str("0h/1/2'"), "0h/1/2'".parse::<DerivationPath>(),
Ok(vec![ Ok(vec![
ChildNumber::ZERO_HARDENED, ChildNumber::ZERO_HARDENED,
ChildNumber::ONE_NORMAL, ChildNumber::ONE_NORMAL,
@ -956,7 +956,7 @@ mod tests {
.into()) .into())
); );
assert_eq!( assert_eq!(
DerivationPath::from_str("0'/1/2h/2"), "0'/1/2h/2".parse::<DerivationPath>(),
Ok(vec![ Ok(vec![
ChildNumber::ZERO_HARDENED, ChildNumber::ZERO_HARDENED,
ChildNumber::ONE_NORMAL, ChildNumber::ONE_NORMAL,
@ -972,27 +972,27 @@ mod tests {
ChildNumber::from_normal_idx(2).unwrap(), ChildNumber::from_normal_idx(2).unwrap(),
ChildNumber::from_normal_idx(1000000000).unwrap(), ChildNumber::from_normal_idx(1000000000).unwrap(),
]); ]);
assert_eq!(DerivationPath::from_str("0'/1/2'/2/1000000000").unwrap(), want); assert_eq!("0'/1/2'/2/1000000000".parse::<DerivationPath>().unwrap(), want);
assert_eq!(DerivationPath::from_str("m/0'/1/2'/2/1000000000").unwrap(), want); assert_eq!("m/0'/1/2'/2/1000000000".parse::<DerivationPath>().unwrap(), want);
let s = "0'/50/3'/5/545456"; let s = "0'/50/3'/5/545456";
assert_eq!(DerivationPath::from_str(s), s.into_derivation_path()); assert_eq!(s.parse::<DerivationPath>(), s.into_derivation_path());
assert_eq!(DerivationPath::from_str(s), s.to_string().into_derivation_path()); assert_eq!(s.parse::<DerivationPath>(), s.to_string().into_derivation_path());
let s = "m/0'/50/3'/5/545456"; let s = "m/0'/50/3'/5/545456";
assert_eq!(DerivationPath::from_str(s), s.into_derivation_path()); assert_eq!(s.parse::<DerivationPath>(), s.into_derivation_path());
assert_eq!(DerivationPath::from_str(s), s.to_string().into_derivation_path()); assert_eq!(s.parse::<DerivationPath>(), s.to_string().into_derivation_path());
} }
#[test] #[test]
fn test_derivation_path_conversion_index() { fn test_derivation_path_conversion_index() {
let path = DerivationPath::from_str("0h/1/2'").unwrap(); let path = "0h/1/2'".parse::<DerivationPath>().unwrap();
let numbers: Vec<ChildNumber> = path.clone().into(); let numbers: Vec<ChildNumber> = path.clone().into();
let path2: DerivationPath = numbers.into(); let path2: DerivationPath = numbers.into();
assert_eq!(path, path2); assert_eq!(path, path2);
assert_eq!(&path[..2], &[ChildNumber::ZERO_HARDENED, ChildNumber::ONE_NORMAL]); assert_eq!(&path[..2], &[ChildNumber::ZERO_HARDENED, ChildNumber::ONE_NORMAL]);
let indexed: DerivationPath = path[..2].into(); let indexed: DerivationPath = path[..2].into();
assert_eq!(indexed, DerivationPath::from_str("0h/1").unwrap()); assert_eq!(indexed, "0h/1".parse::<DerivationPath>().unwrap());
assert_eq!(indexed.child(ChildNumber::from_hardened_idx(2).unwrap()), path); assert_eq!(indexed.child(ChildNumber::from_hardened_idx(2).unwrap()), path);
} }
@ -1038,8 +1038,8 @@ mod tests {
assert_eq!(&sk.to_string()[..], expected_sk); assert_eq!(&sk.to_string()[..], expected_sk);
assert_eq!(&pk.to_string()[..], expected_pk); assert_eq!(&pk.to_string()[..], expected_pk);
// Check decoded base58 against result // Check decoded base58 against result
let decoded_sk = Xpriv::from_str(expected_sk); let decoded_sk = expected_sk.parse::<Xpriv>();
let decoded_pk = Xpub::from_str(expected_pk); let decoded_pk = expected_pk.parse::<Xpub>();
assert_eq!(Ok(sk), decoded_sk); assert_eq!(Ok(sk), decoded_sk);
assert_eq!(Ok(pk), decoded_pk); assert_eq!(Ok(pk), decoded_pk);
} }
@ -1059,29 +1059,29 @@ mod tests {
assert_eq!(cn.increment().err(), Some(Error::InvalidChildNumber(1 << 31))); assert_eq!(cn.increment().err(), Some(Error::InvalidChildNumber(1 << 31)));
let cn = ChildNumber::from_normal_idx(350).unwrap(); let cn = ChildNumber::from_normal_idx(350).unwrap();
let path = DerivationPath::from_str("42'").unwrap(); let path = "42'".parse::<DerivationPath>().unwrap();
let mut iter = path.children_from(cn); let mut iter = path.children_from(cn);
assert_eq!(iter.next(), Some("42'/350".parse().unwrap())); assert_eq!(iter.next(), Some("42'/350".parse().unwrap()));
assert_eq!(iter.next(), Some("42'/351".parse().unwrap())); assert_eq!(iter.next(), Some("42'/351".parse().unwrap()));
let path = DerivationPath::from_str("42'/350'").unwrap(); let path = "42'/350'".parse::<DerivationPath>().unwrap();
let mut iter = path.normal_children(); let mut iter = path.normal_children();
assert_eq!(iter.next(), Some("42'/350'/0".parse().unwrap())); assert_eq!(iter.next(), Some("42'/350'/0".parse().unwrap()));
assert_eq!(iter.next(), Some("42'/350'/1".parse().unwrap())); assert_eq!(iter.next(), Some("42'/350'/1".parse().unwrap()));
let path = DerivationPath::from_str("42'/350'").unwrap(); let path = "42'/350'".parse::<DerivationPath>().unwrap();
let mut iter = path.hardened_children(); let mut iter = path.hardened_children();
assert_eq!(iter.next(), Some("42'/350'/0'".parse().unwrap())); assert_eq!(iter.next(), Some("42'/350'/0'".parse().unwrap()));
assert_eq!(iter.next(), Some("42'/350'/1'".parse().unwrap())); assert_eq!(iter.next(), Some("42'/350'/1'".parse().unwrap()));
let cn = ChildNumber::from_hardened_idx(42350).unwrap(); let cn = ChildNumber::from_hardened_idx(42350).unwrap();
let path = DerivationPath::from_str("42'").unwrap(); let path = "42'".parse::<DerivationPath>().unwrap();
let mut iter = path.children_from(cn); let mut iter = path.children_from(cn);
assert_eq!(iter.next(), Some("42'/42350'".parse().unwrap())); assert_eq!(iter.next(), Some("42'/42350'".parse().unwrap()));
assert_eq!(iter.next(), Some("42'/42351'".parse().unwrap())); assert_eq!(iter.next(), Some("42'/42351'".parse().unwrap()));
let cn = ChildNumber::from_hardened_idx(max).unwrap(); let cn = ChildNumber::from_hardened_idx(max).unwrap();
let path = DerivationPath::from_str("42'").unwrap(); let path = "42'".parse::<DerivationPath>().unwrap();
let mut iter = path.children_from(cn); let mut iter = path.children_from(cn);
assert!(iter.next().is_some()); assert!(iter.next().is_some());
assert!(iter.next().is_none()); assert!(iter.next().is_none());
@ -1246,7 +1246,7 @@ mod tests {
// Xpriv having secret key set to all zeros // Xpriv having secret key set to all zeros
let xpriv_str = "xprv9s21ZrQH143K24Mfq5zL5MhWK9hUhhGbd45hLXo2Pq2oqzMMo63oStZzF93Y5wvzdUayhgkkFoicQZcP3y52uPPxFnfoLZB21Teqt1VvEHx"; let xpriv_str = "xprv9s21ZrQH143K24Mfq5zL5MhWK9hUhhGbd45hLXo2Pq2oqzMMo63oStZzF93Y5wvzdUayhgkkFoicQZcP3y52uPPxFnfoLZB21Teqt1VvEHx";
Xpriv::from_str(xpriv_str).unwrap(); xpriv_str.parse::<Xpriv>().unwrap();
} }
#[test] #[test]
@ -1254,6 +1254,6 @@ mod tests {
fn schnorr_broken_privkey_ffs() { fn schnorr_broken_privkey_ffs() {
// Xpriv having secret key set to all 0xFF's // Xpriv having secret key set to all 0xFF's
let xpriv_str = "xprv9s21ZrQH143K24Mfq5zL5MhWK9hUhhGbd45hLXo2Pq2oqzMMo63oStZzFAzHGBP2UuGCqWLTAPLcMtD9y5gkZ6Eq3Rjuahrv17fENZ3QzxW"; let xpriv_str = "xprv9s21ZrQH143K24Mfq5zL5MhWK9hUhhGbd45hLXo2Pq2oqzMMo63oStZzFAzHGBP2UuGCqWLTAPLcMtD9y5gkZ6Eq3Rjuahrv17fENZ3QzxW";
Xpriv::from_str(xpriv_str).unwrap(); xpriv_str.parse::<Xpriv>().unwrap();
} }
} }

4
bitcoin/src/blockdata/constants.rs
View File

@ -209,8 +209,6 @@ impl ChainHash {
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use core::str::FromStr;
use hex::test_hex_unwrap as hex; use hex::test_hex_unwrap as hex;
use super::*; use super::*;
@ -233,7 +231,7 @@ mod test {
assert_eq!(gen.output.len(), 1); assert_eq!(gen.output.len(), 1);
assert_eq!(serialize(&gen.output[0].script_pubkey), assert_eq!(serialize(&gen.output[0].script_pubkey),
hex!("434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac")); hex!("434104678afdb0fe5548271967f1a67130b7105cd6a828e03909a67962e0ea1f61deb649f6bc3f4cef38c4f35504e51ec112de5c384df7ba0b8d578a4c702b6bf11d5fac"));
assert_eq!(gen.output[0].value, Amount::from_str("50 BTC").unwrap()); assert_eq!(gen.output[0].value, "50 BTC".parse::<Amount>().unwrap());
assert_eq!(gen.lock_time, absolute::LockTime::ZERO); assert_eq!(gen.lock_time, absolute::LockTime::ZERO);
assert_eq!( assert_eq!(

30
bitcoin/src/blockdata/script/tests.rs
View File

@ -1,7 +1,5 @@
// SPDX-License-Identifier: CC0-1.0 // SPDX-License-Identifier: CC0-1.0
use core::str::FromStr;
use hex_lit::hex; use hex_lit::hex;
use super::*; use super::*;
@ -38,10 +36,10 @@ fn script() {
// keys // keys
const KEYSTR1: &str = "21032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af"; const KEYSTR1: &str = "21032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af";
let key = PublicKey::from_str(&KEYSTR1[2..]).unwrap(); let key = KEYSTR1[2..].parse::<PublicKey>().unwrap();
script = script.push_key(key); comp.extend_from_slice(&hex!(KEYSTR1)); assert_eq!(script.as_bytes(), &comp[..]); script = script.push_key(key); comp.extend_from_slice(&hex!(KEYSTR1)); assert_eq!(script.as_bytes(), &comp[..]);
const KEYSTR2: &str = "41042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b133"; const KEYSTR2: &str = "41042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b133";
let key = PublicKey::from_str(&KEYSTR2[2..]).unwrap(); let key = KEYSTR2[2..].parse::<PublicKey>().unwrap();
script = script.push_key(key); comp.extend_from_slice(&hex!(KEYSTR2)); assert_eq!(script.as_bytes(), &comp[..]); script = script.push_key(key); comp.extend_from_slice(&hex!(KEYSTR2)); assert_eq!(script.as_bytes(), &comp[..]);
// opcodes // opcodes
@ -52,7 +50,7 @@ fn script() {
#[test] #[test]
fn p2pk_pubkey_bytes_valid_key_and_valid_script_returns_expected_key() { fn p2pk_pubkey_bytes_valid_key_and_valid_script_returns_expected_key() {
let key_str = "0411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3"; let key_str = "0411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3";
let key = PublicKey::from_str(key_str).unwrap(); let key = key_str.parse::<PublicKey>().unwrap();
let p2pk = Script::builder().push_key(key).push_opcode(OP_CHECKSIG).into_script(); let p2pk = Script::builder().push_key(key).push_opcode(OP_CHECKSIG).into_script();
let actual = p2pk.p2pk_pubkey_bytes().unwrap(); let actual = p2pk.p2pk_pubkey_bytes().unwrap();
assert_eq!(actual.to_vec(), key.to_bytes()); assert_eq!(actual.to_vec(), key.to_bytes());
@ -61,7 +59,7 @@ fn p2pk_pubkey_bytes_valid_key_and_valid_script_returns_expected_key() {
#[test] #[test]
fn p2pk_pubkey_bytes_no_checksig_returns_none() { fn p2pk_pubkey_bytes_no_checksig_returns_none() {
let key_str = "0411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3"; let key_str = "0411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3";
let key = PublicKey::from_str(key_str).unwrap(); let key = key_str.parse::<PublicKey>().unwrap();
let no_checksig = Script::builder().push_key(key).into_script(); let no_checksig = Script::builder().push_key(key).into_script();
assert_eq!(no_checksig.p2pk_pubkey_bytes(), None); assert_eq!(no_checksig.p2pk_pubkey_bytes(), None);
} }
@ -82,7 +80,7 @@ fn p2pk_pubkey_bytes_no_key_returns_none() {
#[test] #[test]
fn p2pk_pubkey_bytes_different_op_code_returns_none() { fn p2pk_pubkey_bytes_different_op_code_returns_none() {
let key_str = "0411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3"; let key_str = "0411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3";
let key = PublicKey::from_str(key_str).unwrap(); let key = key_str.parse::<PublicKey>().unwrap();
let different_op_code = Script::builder().push_key(key).push_opcode(OP_NOP).into_script(); let different_op_code = Script::builder().push_key(key).push_opcode(OP_NOP).into_script();
assert!(different_op_code.p2pk_pubkey_bytes().is_none()); assert!(different_op_code.p2pk_pubkey_bytes().is_none());
} }
@ -107,7 +105,7 @@ fn p2pk_pubkey_bytes_invalid_key_returns_some() {
#[test] #[test]
fn p2pk_pubkey_bytes_compressed_key_returns_expected_key() { fn p2pk_pubkey_bytes_compressed_key_returns_expected_key() {
let compressed_key_str = "0311db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5c"; let compressed_key_str = "0311db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5c";
let key = PublicKey::from_str(compressed_key_str).unwrap(); let key = compressed_key_str.parse::<PublicKey>().unwrap();
let p2pk = Script::builder().push_key(key).push_opcode(OP_CHECKSIG).into_script(); let p2pk = Script::builder().push_key(key).push_opcode(OP_CHECKSIG).into_script();
let actual = p2pk.p2pk_pubkey_bytes().unwrap(); let actual = p2pk.p2pk_pubkey_bytes().unwrap();
assert_eq!(actual.to_vec(), key.to_bytes()); assert_eq!(actual.to_vec(), key.to_bytes());
@ -116,7 +114,7 @@ fn p2pk_pubkey_bytes_compressed_key_returns_expected_key() {
#[test] #[test]
fn p2pk_public_key_valid_key_and_valid_script_returns_expected_key() { fn p2pk_public_key_valid_key_and_valid_script_returns_expected_key() {
let key_str = "0411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3"; let key_str = "0411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3";
let key = PublicKey::from_str(key_str).unwrap(); let key = key_str.parse::<PublicKey>().unwrap();
let p2pk = Script::builder().push_key(key).push_opcode(OP_CHECKSIG).into_script(); let p2pk = Script::builder().push_key(key).push_opcode(OP_CHECKSIG).into_script();
let actual = p2pk.p2pk_public_key().unwrap(); let actual = p2pk.p2pk_public_key().unwrap();
assert_eq!(actual, key); assert_eq!(actual, key);
@ -125,7 +123,7 @@ fn p2pk_public_key_valid_key_and_valid_script_returns_expected_key() {
#[test] #[test]
fn p2pk_public_key_no_checksig_returns_none() { fn p2pk_public_key_no_checksig_returns_none() {
let key_str = "0411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3"; let key_str = "0411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3";
let key = PublicKey::from_str(key_str).unwrap(); let key = key_str.parse::<PublicKey>().unwrap();
let no_checksig = Script::builder().push_key(key).into_script(); let no_checksig = Script::builder().push_key(key).into_script();
assert_eq!(no_checksig.p2pk_public_key(), None); assert_eq!(no_checksig.p2pk_public_key(), None);
} }
@ -145,7 +143,7 @@ fn p2pk_public_key_no_key_returns_none() {
#[test] #[test]
fn p2pk_public_key_different_op_code_returns_none() { fn p2pk_public_key_different_op_code_returns_none() {
let key_str = "0411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3"; let key_str = "0411db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5cb2e0eaddfb84ccf9744464f82e160bfa9b8b64f9d4c03f999b8643f656b412a3";
let key = PublicKey::from_str(key_str).unwrap(); let key = key_str.parse::<PublicKey>().unwrap();
let different_op_code = Script::builder().push_key(key).push_opcode(OP_NOP).into_script(); let different_op_code = Script::builder().push_key(key).push_opcode(OP_NOP).into_script();
assert!(different_op_code.p2pk_public_key().is_none()); assert!(different_op_code.p2pk_public_key().is_none());
} }
@ -169,7 +167,7 @@ fn p2pk_public_key_invalid_key_returns_none() {
#[test] #[test]
fn p2pk_public_key_compressed_key_returns_some() { fn p2pk_public_key_compressed_key_returns_some() {
let compressed_key_str = "0311db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5c"; let compressed_key_str = "0311db93e1dcdb8a016b49840f8c53bc1eb68a382e97b1482ecad7b148a6909a5c";
let key = PublicKey::from_str(compressed_key_str).unwrap(); let key = compressed_key_str.parse::<PublicKey>().unwrap();
let p2pk = Script::builder().push_key(key).push_opcode(OP_CHECKSIG).into_script(); let p2pk = Script::builder().push_key(key).push_opcode(OP_CHECKSIG).into_script();
let actual = p2pk.p2pk_public_key().unwrap(); let actual = p2pk.p2pk_public_key().unwrap();
assert_eq!(actual, key); assert_eq!(actual, key);
@ -181,7 +179,7 @@ fn script_x_only_key() {
// to our script in order to give a heads up to the script compiler that it should add the next 32 bytes to the stack. // to our script in order to give a heads up to the script compiler that it should add the next 32 bytes to the stack.
// From: https://github.com/bitcoin-core/btcdeb/blob/e8c2750c4a4702768c52d15640ed03bf744d2601/doc/tapscript-example.md?plain=1#L43 // From: https://github.com/bitcoin-core/btcdeb/blob/e8c2750c4a4702768c52d15640ed03bf744d2601/doc/tapscript-example.md?plain=1#L43
const KEYSTR: &str = "209997a497d964fc1a62885b05a51166a65a90df00492c8d7cf61d6accf54803be"; const KEYSTR: &str = "209997a497d964fc1a62885b05a51166a65a90df00492c8d7cf61d6accf54803be";
let x_only_key = XOnlyPublicKey::from_str(&KEYSTR[2..]).unwrap(); let x_only_key = KEYSTR[2..].parse::<XOnlyPublicKey>().unwrap();
let script = Builder::new().push_x_only_key(x_only_key); let script = Builder::new().push_x_only_key(x_only_key);
assert_eq!(script.into_bytes(), &hex!(KEYSTR) as &[u8]); assert_eq!(script.into_bytes(), &hex!(KEYSTR) as &[u8]);
} }
@ -201,9 +199,9 @@ fn script_builder() {
#[test] #[test]
fn script_generators() { fn script_generators() {
let pubkey = let pubkey = "0234e6a79c5359c613762d537e0e19d86c77c1666d8c9ab050f23acd198e97f93e"
PublicKey::from_str("0234e6a79c5359c613762d537e0e19d86c77c1666d8c9ab050f23acd198e97f93e") .parse::<PublicKey>()
.unwrap(); .unwrap();
assert!(ScriptBuf::new_p2pk(pubkey).is_p2pk()); assert!(ScriptBuf::new_p2pk(pubkey).is_p2pk());
let pubkey_hash = pubkey.pubkey_hash(); let pubkey_hash = pubkey.pubkey_hash();

56
bitcoin/src/blockdata/transaction.rs
View File

@ -1438,8 +1438,6 @@ impl InputWeightPrediction {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use core::str::FromStr;
use hex::{test_hex_unwrap as hex, FromHex}; use hex::{test_hex_unwrap as hex, FromHex};
#[cfg(feature = "serde")] #[cfg(feature = "serde")]
use internals::serde_round_trip; use internals::serde_round_trip;
@ -1464,43 +1462,38 @@ mod tests {
#[test] #[test]
fn outpoint() { fn outpoint() {
assert_eq!(OutPoint::from_str("i don't care"), Err(ParseOutPointError::Format)); assert_eq!("i don't care".parse::<OutPoint>(), Err(ParseOutPointError::Format));
assert_eq!( assert_eq!(
OutPoint::from_str( "5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:1:1"
"5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:1:1" .parse::<OutPoint>(),
),
Err(ParseOutPointError::Format) Err(ParseOutPointError::Format)
); );
assert_eq!( assert_eq!(
OutPoint::from_str("5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:"), "5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:".parse::<OutPoint>(),
Err(ParseOutPointError::Format) Err(ParseOutPointError::Format)
); );
assert_eq!( assert_eq!(
OutPoint::from_str( "5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:11111111111"
"5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:11111111111" .parse::<OutPoint>(),
),
Err(ParseOutPointError::TooLong) Err(ParseOutPointError::TooLong)
); );
assert_eq!( assert_eq!(
OutPoint::from_str( "5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:01"
"5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:01" .parse::<OutPoint>(),
),
Err(ParseOutPointError::VoutNotCanonical) Err(ParseOutPointError::VoutNotCanonical)
); );
assert_eq!( assert_eq!(
OutPoint::from_str( "5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:+42"
"5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:+42" .parse::<OutPoint>(),
),
Err(ParseOutPointError::VoutNotCanonical) Err(ParseOutPointError::VoutNotCanonical)
); );
assert_eq!( assert_eq!(
OutPoint::from_str("i don't care:1"), "i don't care:1".parse::<OutPoint>(),
Err(ParseOutPointError::Txid("i don't care".parse::<Txid>().unwrap_err())) Err(ParseOutPointError::Txid("i don't care".parse::<Txid>().unwrap_err()))
); );
assert_eq!( assert_eq!(
OutPoint::from_str( "5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c945X:1"
"5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c945X:1" .parse::<OutPoint>(),
),
Err(ParseOutPointError::Txid( Err(ParseOutPointError::Txid(
"5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c945X" "5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c945X"
.parse::<Txid>() .parse::<Txid>()
@ -1508,16 +1501,14 @@ mod tests {
)) ))
); );
assert_eq!( assert_eq!(
OutPoint::from_str( "5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:lol"
"5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:lol" .parse::<OutPoint>(),
),
Err(ParseOutPointError::Vout(parse::int::<u32, _>("lol").unwrap_err())) Err(ParseOutPointError::Vout(parse::int::<u32, _>("lol").unwrap_err()))
); );
assert_eq!( assert_eq!(
OutPoint::from_str( "5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:42"
"5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:42" .parse::<OutPoint>(),
),
Ok(OutPoint { Ok(OutPoint {
txid: "5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456" txid: "5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456"
.parse() .parse()
@ -1526,9 +1517,8 @@ mod tests {
}) })
); );
assert_eq!( assert_eq!(
OutPoint::from_str( "5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:0"
"5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456:0" .parse::<OutPoint>(),
),
Ok(OutPoint { Ok(OutPoint {
txid: "5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456" txid: "5df6e0e2761359d30a8275058e299fcc0381534545f55cf43e41983f5d4c9456"
.parse() .parse()
@ -1824,7 +1814,7 @@ mod tests {
]; ];
for (s, sht) in sighashtypes { for (s, sht) in sighashtypes {
assert_eq!(sht.to_string(), s); assert_eq!(sht.to_string(), s);
assert_eq!(EcdsaSighashType::from_str(s).unwrap(), sht); assert_eq!(s.parse::<EcdsaSighashType>().unwrap(), sht);
} }
let sht_mistakes = [ let sht_mistakes = [
"SIGHASH_ALL | SIGHASH_ANYONECANPAY", "SIGHASH_ALL | SIGHASH_ANYONECANPAY",
@ -1840,7 +1830,7 @@ mod tests {
]; ];
for s in sht_mistakes { for s in sht_mistakes {
assert_eq!( assert_eq!(
EcdsaSighashType::from_str(s).unwrap_err().to_string(), s.parse::<EcdsaSighashType>().unwrap_err().to_string(),
format!("unrecognized SIGHASH string '{}'", s) format!("unrecognized SIGHASH string '{}'", s)
); );
} }
@ -1975,13 +1965,13 @@ mod tests {
#[test] #[test]
fn effective_value_happy_path() { fn effective_value_happy_path() {
let value = Amount::from_str("1 cBTC").unwrap(); let value = "1 cBTC".parse::<Amount>().unwrap();
let fee_rate = FeeRate::from_sat_per_kwu(10); let fee_rate = FeeRate::from_sat_per_kwu(10);
let satisfaction_weight = Weight::from_wu(204); let satisfaction_weight = Weight::from_wu(204);
let effective_value = effective_value(fee_rate, satisfaction_weight, value).unwrap(); let effective_value = effective_value(fee_rate, satisfaction_weight, value).unwrap();
// 10 sat/kwu * (204wu + BASE_WEIGHT) = 4 sats // 10 sat/kwu * (204wu + BASE_WEIGHT) = 4 sats
let expected_fee = SignedAmount::from_str("4 sats").unwrap(); let expected_fee = "4 sats".parse::<SignedAmount>().unwrap();
let expected_effective_value = value.to_signed().unwrap() - expected_fee; let expected_effective_value = value.to_signed().unwrap() - expected_fee;
assert_eq!(effective_value, expected_effective_value); assert_eq!(effective_value, expected_effective_value);
} }

65
bitcoin/src/crypto/key.rs
View File

@ -1151,7 +1151,7 @@ mod tests {
// test string conversion // test string conversion
assert_eq!(&sk.to_string(), "cVt4o7BGAig1UXywgGSmARhxMdzP5qvQsxKkSsc1XEkw3tDTQFpy"); assert_eq!(&sk.to_string(), "cVt4o7BGAig1UXywgGSmARhxMdzP5qvQsxKkSsc1XEkw3tDTQFpy");
let sk_str = let sk_str =
PrivateKey::from_str("cVt4o7BGAig1UXywgGSmARhxMdzP5qvQsxKkSsc1XEkw3tDTQFpy").unwrap(); "cVt4o7BGAig1UXywgGSmARhxMdzP5qvQsxKkSsc1XEkw3tDTQFpy".parse::<PrivateKey>().unwrap();
assert_eq!(&sk.to_wif(), &sk_str.to_wif()); assert_eq!(&sk.to_wif(), &sk_str.to_wif());
// mainnet uncompressed // mainnet uncompressed
@ -1165,7 +1165,8 @@ mod tests {
let mut pk = sk.public_key(&secp); let mut pk = sk.public_key(&secp);
assert!(!pk.compressed); assert!(!pk.compressed);
assert_eq!(&pk.to_string(), "042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b133"); assert_eq!(&pk.to_string(), "042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b133");
assert_eq!(pk, PublicKey::from_str("042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b133").unwrap()); assert_eq!(pk, "042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b133"
.parse::<PublicKey>().unwrap());
let addr = Address::p2pkh(pk, sk.network); let addr = Address::p2pkh(pk, sk.network);
assert_eq!(&addr.to_string(), "1GhQvF6dL8xa6wBxLnWmHcQsurx9RxiMc8"); assert_eq!(&addr.to_string(), "1GhQvF6dL8xa6wBxLnWmHcQsurx9RxiMc8");
pk.compressed = true; pk.compressed = true;
@ -1175,31 +1176,29 @@ mod tests {
); );
assert_eq!( assert_eq!(
pk, pk,
PublicKey::from_str( "032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af"
"032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af" .parse::<PublicKey>()
) .unwrap()
.unwrap()
); );
} }
#[test] #[test]
fn test_pubkey_hash() { fn test_pubkey_hash() {
let pk = PublicKey::from_str( let pk = "032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af"
"032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af", .parse::<PublicKey>()
) .unwrap();
.unwrap(); let upk = "042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b133"
let upk = PublicKey::from_str("042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b133").unwrap(); .parse::<PublicKey>().unwrap();
assert_eq!(pk.pubkey_hash().to_string(), "9511aa27ef39bbfa4e4f3dd15f4d66ea57f475b4"); assert_eq!(pk.pubkey_hash().to_string(), "9511aa27ef39bbfa4e4f3dd15f4d66ea57f475b4");
assert_eq!(upk.pubkey_hash().to_string(), "ac2e7daf42d2c97418fd9f78af2de552bb9c6a7a"); assert_eq!(upk.pubkey_hash().to_string(), "ac2e7daf42d2c97418fd9f78af2de552bb9c6a7a");
} }
#[test] #[test]
fn test_wpubkey_hash() { fn test_wpubkey_hash() {
let pk = PublicKey::from_str( let pk = "032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af"
"032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af", .parse::<PublicKey>()
) .unwrap();
.unwrap(); let upk = "042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b133".parse::<PublicKey>().unwrap();
let upk = PublicKey::from_str("042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b133").unwrap();
assert_eq!( assert_eq!(
pk.wpubkey_hash().unwrap().to_string(), pk.wpubkey_hash().unwrap().to_string(),
"9511aa27ef39bbfa4e4f3dd15f4d66ea57f475b4" "9511aa27ef39bbfa4e4f3dd15f4d66ea57f475b4"
@ -1241,7 +1240,7 @@ mod tests {
]; ];
let s = Secp256k1::new(); let s = Secp256k1::new();
let sk = PrivateKey::from_str(KEY_WIF).unwrap(); let sk = KEY_WIF.parse::<PrivateKey>().unwrap();
let pk = PublicKey::from_private_key(&s, sk); let pk = PublicKey::from_private_key(&s, sk);
let pk_u = PublicKey { inner: pk.inner, compressed: false }; let pk_u = PublicKey { inner: pk.inner, compressed: false };
@ -1303,10 +1302,9 @@ mod tests {
#[test] #[test]
fn pubkey_to_sort_key() { fn pubkey_to_sort_key() {
let key1 = PublicKey::from_str( let key1 = "02ff12471208c14bd580709cb2358d98975247d8765f92bc25eab3b2763ed605f8"
"02ff12471208c14bd580709cb2358d98975247d8765f92bc25eab3b2763ed605f8", .parse::<PublicKey>()
) .unwrap();
.unwrap();
let key2 = PublicKey { inner: key1.inner, compressed: false }; let key2 = PublicKey { inner: key1.inner, compressed: false };
let arrayvec1 = ArrayVec::from_slice( let arrayvec1 = ArrayVec::from_slice(
&<[u8; 33]>::from_hex( &<[u8; 33]>::from_hex(
@ -1329,8 +1327,9 @@ mod tests {
input: Vec<PublicKey>, input: Vec<PublicKey>,
expect: Vec<PublicKey>, expect: Vec<PublicKey>,
} }
let fmt = let fmt = |v: Vec<_>| {
|v: Vec<_>| v.into_iter().map(|s| PublicKey::from_str(s).unwrap()).collect::<Vec<_>>(); v.into_iter().map(|s: &str| s.parse::<PublicKey>().unwrap()).collect::<Vec<_>>()
};
let vectors = vec![ let vectors = vec![
// Start BIP67 vectors // Start BIP67 vectors
// Vector 1 // Vector 1
@ -1449,15 +1448,15 @@ mod tests {
// Sanity checks, we accept string length 130 digits. // Sanity checks, we accept string length 130 digits.
let s = "042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b133"; let s = "042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b133";
assert_eq!(s.len(), 130); assert_eq!(s.len(), 130);
assert!(PublicKey::from_str(s).is_ok()); assert!(s.parse::<PublicKey>().is_ok());
// And 66 digits. // And 66 digits.
let s = "032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af"; let s = "032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af";
assert_eq!(s.len(), 66); assert_eq!(s.len(), 66);
assert!(PublicKey::from_str(s).is_ok()); assert!(s.parse::<PublicKey>().is_ok());
let s = "aoeusthb"; let s = "aoeusthb";
assert_eq!(s.len(), 8); assert_eq!(s.len(), 8);
let res = PublicKey::from_str(s); let res = s.parse::<PublicKey>();
assert!(res.is_err()); assert!(res.is_err());
assert_eq!(res.unwrap_err(), ParsePublicKeyError::InvalidHexLength(8)); assert_eq!(res.unwrap_err(), ParsePublicKeyError::InvalidHexLength(8));
} }
@ -1467,7 +1466,7 @@ mod tests {
// Ensuring test cases fail when PublicKey::from_str is used on invalid keys // Ensuring test cases fail when PublicKey::from_str is used on invalid keys
let s = "042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b142"; let s = "042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b142";
assert_eq!(s.len(), 130); assert_eq!(s.len(), 130);
let res = PublicKey::from_str(s); let res = s.parse::<PublicKey>();
assert!(res.is_err()); assert!(res.is_err());
assert_eq!( assert_eq!(
res.unwrap_err(), res.unwrap_err(),
@ -1478,7 +1477,7 @@ mod tests {
let s = "032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd169"; let s = "032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd169";
assert_eq!(s.len(), 66); assert_eq!(s.len(), 66);
let res = PublicKey::from_str(s); let res = s.parse::<PublicKey>();
assert!(res.is_err()); assert!(res.is_err());
assert_eq!( assert_eq!(
res.unwrap_err(), res.unwrap_err(),
@ -1489,7 +1488,7 @@ mod tests {
let s = "062e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b133"; let s = "062e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b133";
assert_eq!(s.len(), 130); assert_eq!(s.len(), 130);
let res = PublicKey::from_str(s); let res = s.parse::<PublicKey>();
assert!(res.is_err()); assert!(res.is_err());
assert_eq!( assert_eq!(
res.unwrap_err(), res.unwrap_err(),
@ -1498,13 +1497,13 @@ mod tests {
let s = "042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b13g"; let s = "042e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1af191923a2964c177f5b5923ae500fca49e99492d534aa3759d6b25a8bc971b13g";
assert_eq!(s.len(), 130); assert_eq!(s.len(), 130);
let res = PublicKey::from_str(s); let res = s.parse::<PublicKey>();
assert!(res.is_err()); assert!(res.is_err());
assert_eq!(res.unwrap_err(), ParsePublicKeyError::InvalidChar(103)); assert_eq!(res.unwrap_err(), ParsePublicKeyError::InvalidChar(103));
let s = "032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1ag"; let s = "032e58afe51f9ed8ad3cc7897f634d881fdbe49a81564629ded8156bebd2ffd1ag";
assert_eq!(s.len(), 66); assert_eq!(s.len(), 66);
let res = PublicKey::from_str(s); let res = s.parse::<PublicKey>();
assert!(res.is_err()); assert!(res.is_err());
assert_eq!(res.unwrap_err(), ParsePublicKeyError::InvalidChar(103)); assert_eq!(res.unwrap_err(), ParsePublicKeyError::InvalidChar(103));
} }
@ -1513,7 +1512,7 @@ mod tests {
#[cfg(feature = "std")] #[cfg(feature = "std")]
fn private_key_debug_is_obfuscated() { fn private_key_debug_is_obfuscated() {
let sk = let sk =
PrivateKey::from_str("cVt4o7BGAig1UXywgGSmARhxMdzP5qvQsxKkSsc1XEkw3tDTQFpy").unwrap(); "cVt4o7BGAig1UXywgGSmARhxMdzP5qvQsxKkSsc1XEkw3tDTQFpy".parse::<PrivateKey>().unwrap();
let want = let want =
"PrivateKey { compressed: true, network: Test, inner: SecretKey(#32014e414fdce702) }"; "PrivateKey { compressed: true, network: Test, inner: SecretKey(#32014e414fdce702) }";
let got = format!("{:?}", sk); let got = format!("{:?}", sk);
@ -1524,7 +1523,7 @@ mod tests {
#[cfg(not(feature = "std"))] #[cfg(not(feature = "std"))]
fn private_key_debug_is_obfuscated() { fn private_key_debug_is_obfuscated() {
let sk = let sk =
PrivateKey::from_str("cVt4o7BGAig1UXywgGSmARhxMdzP5qvQsxKkSsc1XEkw3tDTQFpy").unwrap(); "cVt4o7BGAig1UXywgGSmARhxMdzP5qvQsxKkSsc1XEkw3tDTQFpy".parse::<PrivateKey>().unwrap();
// Why is this not shortened? In rust-secp256k1/src/secret it is printed with "#{:016x}"? // Why is this not shortened? In rust-secp256k1/src/secret it is printed with "#{:016x}"?
let want = "PrivateKey { compressed: true, network: Test, inner: SecretKey(#7217ac58fbad8880a91032107b82cb6c5422544b426c350ee005cf509f3dbf7b) }"; let want = "PrivateKey { compressed: true, network: Test, inner: SecretKey(#7217ac58fbad8880a91032107b82cb6c5422544b426c350ee005cf509f3dbf7b) }";
let got = format!("{:?}", sk); let got = format!("{:?}", sk);

13
bitcoin/src/crypto/sighash.rs
View File

@ -1468,8 +1468,6 @@ impl<E: std::error::Error + 'static> std::error::Error for SigningDataError<E> {
#[cfg(test)] #[cfg(test)]
mod tests { mod tests {
use std::str::FromStr;
use hashes::HashEngine; use hashes::HashEngine;
use hex::{test_hex_unwrap as hex, FromHex}; use hex::{test_hex_unwrap as hex, FromHex};
@ -1927,14 +1925,11 @@ mod tests {
let expected = inp.intermediary; let expected = inp.intermediary;
let sig_str = inp.expected.witness.remove(0); let sig_str = inp.expected.witness.remove(0);
let (expected_key_spend_sig, expected_hash_ty) = if sig_str.len() == 128 { let (expected_key_spend_sig, expected_hash_ty) = if sig_str.len() == 128 {
( (sig_str.parse::<secp256k1::schnorr::Signature>().unwrap(), TapSighashType::Default)
secp256k1::schnorr::Signature::from_str(&sig_str).unwrap(),
TapSighashType::Default,
)
} else { } else {
let hash_ty = u8::from_str_radix(&sig_str[128..130], 16).unwrap(); let hash_ty = u8::from_str_radix(&sig_str[128..130], 16).unwrap();
let hash_ty = TapSighashType::from_consensus_u8(hash_ty).unwrap(); let hash_ty = TapSighashType::from_consensus_u8(hash_ty).unwrap();
(secp256k1::schnorr::Signature::from_str(&sig_str[..128]).unwrap(), hash_ty) (sig_str[..128].parse::<secp256k1::schnorr::Signature>().unwrap(), hash_ty)
}; };
// tests // tests
@ -1985,7 +1980,7 @@ mod tests {
]; ];
for (s, sht) in sighashtypes { for (s, sht) in sighashtypes {
assert_eq!(sht.to_string(), s); assert_eq!(sht.to_string(), s);
assert_eq!(TapSighashType::from_str(s).unwrap(), sht); assert_eq!(s.parse::<TapSighashType>().unwrap(), sht);
} }
let sht_mistakes = [ let sht_mistakes = [
"SIGHASH_ALL | SIGHASH_ANYONECANPAY", "SIGHASH_ALL | SIGHASH_ANYONECANPAY",
@ -2003,7 +1998,7 @@ mod tests {
]; ];
for s in sht_mistakes { for s in sht_mistakes {
assert_eq!( assert_eq!(
TapSighashType::from_str(s).unwrap_err().to_string(), s.parse::<TapSighashType>().unwrap_err().to_string(),
format!("unrecognized SIGHASH string '{}'", s) format!("unrecognized SIGHASH string '{}'", s)
); );
} }

11
bitcoin/src/p2p/address.rs
View File

@ -302,7 +302,6 @@ impl ToSocketAddrs for AddrV2Message {
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use core::str::FromStr;
use std::net::IpAddr; use std::net::IpAddr;
use hex::{test_hex_unwrap as hex, FromHex}; use hex::{test_hex_unwrap as hex, FromHex};
@ -384,7 +383,7 @@ mod test {
#[test] #[test]
fn onion_test() { fn onion_test() {
let onionaddr = SocketAddr::new( let onionaddr = SocketAddr::new(
IpAddr::V6(Ipv6Addr::from_str("FD87:D87E:EB43:edb1:8e4:3588:e546:35ca").unwrap()), IpAddr::V6("FD87:D87E:EB43:edb1:8e4:3588:e546:35ca".parse::<Ipv6Addr>().unwrap()),
1111, 1111,
); );
let addr = Address::new(&onionaddr, ServiceFlags::NONE); let addr = Address::new(&onionaddr, ServiceFlags::NONE);
@ -399,7 +398,7 @@ mod test {
assert_eq!(serialize(&ip), hex!("010401020304")); assert_eq!(serialize(&ip), hex!("010401020304"));
let ip = let ip =
AddrV2::Ipv6(Ipv6Addr::from_str("1a1b:2a2b:3a3b:4a4b:5a5b:6a6b:7a7b:8a8b").unwrap()); AddrV2::Ipv6("1a1b:2a2b:3a3b:4a4b:5a5b:6a6b:7a7b:8a8b".parse::<Ipv6Addr>().unwrap());
assert_eq!(serialize(&ip), hex!("02101a1b2a2b3a3b4a4b5a5b6a6b7a7b8a8b")); assert_eq!(serialize(&ip), hex!("02101a1b2a2b3a3b4a4b5a5b6a6b7a7b8a8b"));
let ip = AddrV2::TorV2(FromHex::from_hex("f1f2f3f4f5f6f7f8f9fa").unwrap()); let ip = AddrV2::TorV2(FromHex::from_hex("f1f2f3f4f5f6f7f8f9fa").unwrap());
@ -423,7 +422,7 @@ mod test {
hex!("0520a2894dabaec08c0051a481a6dac88b64f98232ae42d4b6fd2fa81952dfe36a87") hex!("0520a2894dabaec08c0051a481a6dac88b64f98232ae42d4b6fd2fa81952dfe36a87")
); );
let ip = AddrV2::Cjdns(Ipv6Addr::from_str("fc01:1:2:3:4:5:6:7").unwrap()); let ip = AddrV2::Cjdns("fc01:1:2:3:4:5:6:7".parse::<Ipv6Addr>().unwrap());
assert_eq!(serialize(&ip), hex!("0610fc010001000200030004000500060007")); assert_eq!(serialize(&ip), hex!("0610fc010001000200030004000500060007"));
let ip = AddrV2::Unknown(170, hex!("01020304")); let ip = AddrV2::Unknown(170, hex!("01020304"));
@ -451,7 +450,7 @@ mod test {
let ip: AddrV2 = deserialize(&hex!("02100102030405060708090a0b0c0d0e0f10")).unwrap(); let ip: AddrV2 = deserialize(&hex!("02100102030405060708090a0b0c0d0e0f10")).unwrap();
assert_eq!( assert_eq!(
ip, ip,
AddrV2::Ipv6(Ipv6Addr::from_str("102:304:506:708:90a:b0c:d0e:f10").unwrap()) AddrV2::Ipv6("102:304:506:708:90a:b0c:d0e:f10".parse::<Ipv6Addr>().unwrap())
); );
// Invalid IPv6, with bogus length. // Invalid IPv6, with bogus length.
@ -508,7 +507,7 @@ mod test {
// Valid CJDNS. // Valid CJDNS.
let ip: AddrV2 = deserialize(&hex!("0610fc000001000200030004000500060007")).unwrap(); let ip: AddrV2 = deserialize(&hex!("0610fc000001000200030004000500060007")).unwrap();
assert_eq!(ip, AddrV2::Cjdns(Ipv6Addr::from_str("fc00:1:2:3:4:5:6:7").unwrap())); assert_eq!(ip, AddrV2::Cjdns("fc00:1:2:3:4:5:6:7".parse::<Ipv6Addr>().unwrap()));
// Invalid CJDNS, incorrect marker // Invalid CJDNS, incorrect marker
assert!(deserialize::<AddrV2>(&hex!("0610fd000001000200030004000500060007")).is_err()); assert!(deserialize::<AddrV2>(&hex!("0610fd000001000200030004000500060007")).is_err());

2
bitcoin/src/p2p/mod.rs
View File

@ -433,7 +433,7 @@ mod tests {
]; ];
for (magic_str, network) in &known_network_magic_strs { for (magic_str, network) in &known_network_magic_strs {
let magic: Magic = Magic::from_str(magic_str).unwrap(); let magic: Magic = magic_str.parse::<Magic>().unwrap();
assert_eq!(Network::try_from(magic).unwrap(), *network); assert_eq!(Network::try_from(magic).unwrap(), *network);
assert_eq!(&magic.to_string(), magic_str); assert_eq!(&magic.to_string(), magic_str);
} }

8
bitcoin/src/pow.rs
View File

@ -1865,11 +1865,9 @@ mod tests {
#[test] #[test]
fn target_is_met_by_for_target_equals_hash() { fn target_is_met_by_for_target_equals_hash() {
use std::str::FromStr; let hash = "ef537f25c895bfa782526529a9b63d97aa631564d5d789c2b765448c8635fb6c"
.parse::<BlockHash>()
let hash = .expect("failed to parse block hash");
BlockHash::from_str("ef537f25c895bfa782526529a9b63d97aa631564d5d789c2b765448c8635fb6c")
.expect("failed to parse block hash");
let target = Target(U256::from_le_bytes(hash.to_byte_array())); let target = Target(U256::from_le_bytes(hash.to_byte_array()));
assert!(target.is_met_by(hash)); assert!(target.is_met_by(hash));
} }

6
bitcoin/src/psbt/map/input.rs
View File

@ -523,7 +523,7 @@ mod test {
] { ] {
let sighash = PsbtSighashType::from(*ecdsa); let sighash = PsbtSighashType::from(*ecdsa);
let s = format!("{}", sighash); let s = format!("{}", sighash);
let back = PsbtSighashType::from_str(&s).unwrap(); let back = s.parse::<PsbtSighashType>().unwrap();
assert_eq!(back, sighash); assert_eq!(back, sighash);
assert_eq!(back.ecdsa_hash_ty().unwrap(), *ecdsa); assert_eq!(back.ecdsa_hash_ty().unwrap(), *ecdsa);
} }
@ -542,7 +542,7 @@ mod test {
] { ] {
let sighash = PsbtSighashType::from(*tap); let sighash = PsbtSighashType::from(*tap);
let s = format!("{}", sighash); let s = format!("{}", sighash);
let back = PsbtSighashType::from_str(&s).unwrap(); let back = s.parse::<PsbtSighashType>().unwrap();
assert_eq!(back, sighash); assert_eq!(back, sighash);
assert_eq!(back.taproot_hash_ty().unwrap(), *tap); assert_eq!(back.taproot_hash_ty().unwrap(), *tap);
} }
@ -553,7 +553,7 @@ mod test {
let nonstd = 0xdddddddd; let nonstd = 0xdddddddd;
let sighash = PsbtSighashType { inner: nonstd }; let sighash = PsbtSighashType { inner: nonstd };
let s = format!("{}", sighash); let s = format!("{}", sighash);
let back = PsbtSighashType::from_str(&s).unwrap(); let back = s.parse::<PsbtSighashType>().unwrap();
assert_eq!(back, sighash); assert_eq!(back, sighash);
assert_eq!(back.ecdsa_hash_ty(), Err(NonStandardSighashTypeError(nonstd))); assert_eq!(back.ecdsa_hash_ty(), Err(NonStandardSighashTypeError(nonstd)));

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

@ -1569,9 +1569,6 @@ mod tests {
} }
mod bip_vectors { mod bip_vectors {
#[cfg(feature = "base64")]
use std::str::FromStr;
use super::*; use super::*;
use crate::psbt::map::Map; use crate::psbt::map::Map;
@ -1585,7 +1582,7 @@ mod tests {
#[test] #[test]
#[should_panic(expected = "InvalidMagic")] #[should_panic(expected = "InvalidMagic")]
fn invalid_vector_1_base64() { fn invalid_vector_1_base64() {
Psbt::from_str("AgAAAAEmgXE3Ht/yhek3re6ks3t4AAwFZsuzrWRkFxPKQhcb9gAAAABqRzBEAiBwsiRRI+a/R01gxbUMBD1MaRpdJDXwmjSnZiqdwlF5CgIgATKcqdrPKAvfMHQOwDkEIkIsgctFg5RXrrdvwS7dlbMBIQJlfRGNM1e44PTCzUbbezn22cONmnCry5st5dyNv+TOMf7///8C09/1BQAAAAAZdqkU0MWZA8W6woaHYOkP1SGkZlqnZSCIrADh9QUAAAAAF6kUNUXm4zuDLEcFDyTT7rk8nAOUi8eHsy4TAA==").unwrap(); "AgAAAAEmgXE3Ht/yhek3re6ks3t4AAwFZsuzrWRkFxPKQhcb9gAAAABqRzBEAiBwsiRRI+a/R01gxbUMBD1MaRpdJDXwmjSnZiqdwlF5CgIgATKcqdrPKAvfMHQOwDkEIkIsgctFg5RXrrdvwS7dlbMBIQJlfRGNM1e44PTCzUbbezn22cONmnCry5st5dyNv+TOMf7///8C09/1BQAAAAAZdqkU0MWZA8W6woaHYOkP1SGkZlqnZSCIrADh9QUAAAAAF6kUNUXm4zuDLEcFDyTT7rk8nAOUi8eHsy4TAA==".parse::<Psbt>().unwrap();
} }
#[test] #[test]
@ -1599,7 +1596,7 @@ mod tests {
#[test] #[test]
#[should_panic(expected = "ConsensusEncoding")] #[should_panic(expected = "ConsensusEncoding")]
fn invalid_vector_2_base64() { fn invalid_vector_2_base64() {
Psbt::from_str("cHNidP8BAHUCAAAAASaBcTce3/KF6Tet7qSze3gADAVmy7OtZGQXE8pCFxv2AAAAAAD+////AtPf9QUAAAAAGXapFNDFmQPFusKGh2DpD9UhpGZap2UgiKwA4fUFAAAAABepFDVF5uM7gyxHBQ8k0+65PJwDlIvHh7MuEwAAAQD9pQEBAAAAAAECiaPHHqtNIOA3G7ukzGmPopXJRjr6Ljl/hTPMti+VZ+UBAAAAFxYAFL4Y0VKpsBIDna89p95PUzSe7LmF/////4b4qkOnHf8USIk6UwpyN+9rRgi7st0tAXHmOuxqSJC0AQAAABcWABT+Pp7xp0XpdNkCxDVZQ6vLNL1TU/////8CAMLrCwAAAAAZdqkUhc/xCX/Z4Ai7NK9wnGIZeziXikiIrHL++E4sAAAAF6kUM5cluiHv1irHU6m80GfWx6ajnQWHAkcwRAIgJxK+IuAnDzlPVoMR3HyppolwuAJf3TskAinwf4pfOiQCIAGLONfc0xTnNMkna9b7QPZzMlvEuqFEyADS8vAtsnZcASED0uFWdJQbrUqZY3LLh+GFbTZSYG2YVi/jnF6efkE/IQUCSDBFAiEA0SuFLYXc2WHS9fSrZgZU327tzHlMDDPOXMMJ/7X85Y0CIGczio4OFyXBl/saiK9Z9R5E5CVbIBZ8hoQDHAXR8lkqASECI7cr7vCWXRC+B3jv7NYfysb3mk6haTkzgHNEZPhPKrMAAAAAAA==") "cHNidP8BAHUCAAAAASaBcTce3/KF6Tet7qSze3gADAVmy7OtZGQXE8pCFxv2AAAAAAD+////AtPf9QUAAAAAGXapFNDFmQPFusKGh2DpD9UhpGZap2UgiKwA4fUFAAAAABepFDVF5uM7gyxHBQ8k0+65PJwDlIvHh7MuEwAAAQD9pQEBAAAAAAECiaPHHqtNIOA3G7ukzGmPopXJRjr6Ljl/hTPMti+VZ+UBAAAAFxYAFL4Y0VKpsBIDna89p95PUzSe7LmF/////4b4qkOnHf8USIk6UwpyN+9rRgi7st0tAXHmOuxqSJC0AQAAABcWABT+Pp7xp0XpdNkCxDVZQ6vLNL1TU/////8CAMLrCwAAAAAZdqkUhc/xCX/Z4Ai7NK9wnGIZeziXikiIrHL++E4sAAAAF6kUM5cluiHv1irHU6m80GfWx6ajnQWHAkcwRAIgJxK+IuAnDzlPVoMR3HyppolwuAJf3TskAinwf4pfOiQCIAGLONfc0xTnNMkna9b7QPZzMlvEuqFEyADS8vAtsnZcASED0uFWdJQbrUqZY3LLh+GFbTZSYG2YVi/jnF6efkE/IQUCSDBFAiEA0SuFLYXc2WHS9fSrZgZU327tzHlMDDPOXMMJ/7X85Y0CIGczio4OFyXBl/saiK9Z9R5E5CVbIBZ8hoQDHAXR8lkqASECI7cr7vCWXRC+B3jv7NYfysb3mk6haTkzgHNEZPhPKrMAAAAAAA==".parse::<Psbt>()
.unwrap(); .unwrap();
} }
@ -1613,7 +1610,7 @@ mod tests {
#[test] #[test]
#[should_panic(expected = "UnsignedTxHasScriptSigs")] #[should_panic(expected = "UnsignedTxHasScriptSigs")]
fn invalid_vector_3_base64() { fn invalid_vector_3_base64() {
Psbt::from_str("cHNidP8BAP0KAQIAAAACqwlJoIxa98SbghL0F+LxWrP1wz3PFTghqBOfh3pbe+QAAAAAakcwRAIgR1lmF5fAGwNrJZKJSGhiGDR9iYZLcZ4ff89X0eURZYcCIFMJ6r9Wqk2Ikf/REf3xM286KdqGbX+EhtdVRs7tr5MZASEDXNxh/HupccC1AaZGoqg7ECy0OIEhfKaC3Ibi1z+ogpL+////qwlJoIxa98SbghL0F+LxWrP1wz3PFTghqBOfh3pbe+QBAAAAAP7///8CYDvqCwAAAAAZdqkUdopAu9dAy+gdmI5x3ipNXHE5ax2IrI4kAAAAAAAAGXapFG9GILVT+glechue4O/p+gOcykWXiKwAAAAAAAABASAA4fUFAAAAABepFDVF5uM7gyxHBQ8k0+65PJwDlIvHhwEEFgAUhdE1N/LiZUBaNNuvqePdoB+4IwgAAAA=").unwrap(); "cHNidP8BAP0KAQIAAAACqwlJoIxa98SbghL0F+LxWrP1wz3PFTghqBOfh3pbe+QAAAAAakcwRAIgR1lmF5fAGwNrJZKJSGhiGDR9iYZLcZ4ff89X0eURZYcCIFMJ6r9Wqk2Ikf/REf3xM286KdqGbX+EhtdVRs7tr5MZASEDXNxh/HupccC1AaZGoqg7ECy0OIEhfKaC3Ibi1z+ogpL+////qwlJoIxa98SbghL0F+LxWrP1wz3PFTghqBOfh3pbe+QBAAAAAP7///8CYDvqCwAAAAAZdqkUdopAu9dAy+gdmI5x3ipNXHE5ax2IrI4kAAAAAAAAGXapFG9GILVT+glechue4O/p+gOcykWXiKwAAAAAAAABASAA4fUFAAAAABepFDVF5uM7gyxHBQ8k0+65PJwDlIvHhwEEFgAUhdE1N/LiZUBaNNuvqePdoB+4IwgAAAA=".parse::<Psbt>().unwrap();
} }
#[test] #[test]
@ -1626,7 +1623,7 @@ mod tests {
#[test] #[test]
#[should_panic(expected = "MustHaveUnsignedTx")] #[should_panic(expected = "MustHaveUnsignedTx")]
fn invalid_vector_4_base64() { fn invalid_vector_4_base64() {
Psbt::from_str("cHNidP8AAQD9pQEBAAAAAAECiaPHHqtNIOA3G7ukzGmPopXJRjr6Ljl/hTPMti+VZ+UBAAAAFxYAFL4Y0VKpsBIDna89p95PUzSe7LmF/////4b4qkOnHf8USIk6UwpyN+9rRgi7st0tAXHmOuxqSJC0AQAAABcWABT+Pp7xp0XpdNkCxDVZQ6vLNL1TU/////8CAMLrCwAAAAAZdqkUhc/xCX/Z4Ai7NK9wnGIZeziXikiIrHL++E4sAAAAF6kUM5cluiHv1irHU6m80GfWx6ajnQWHAkcwRAIgJxK+IuAnDzlPVoMR3HyppolwuAJf3TskAinwf4pfOiQCIAGLONfc0xTnNMkna9b7QPZzMlvEuqFEyADS8vAtsnZcASED0uFWdJQbrUqZY3LLh+GFbTZSYG2YVi/jnF6efkE/IQUCSDBFAiEA0SuFLYXc2WHS9fSrZgZU327tzHlMDDPOXMMJ/7X85Y0CIGczio4OFyXBl/saiK9Z9R5E5CVbIBZ8hoQDHAXR8lkqASECI7cr7vCWXRC+B3jv7NYfysb3mk6haTkzgHNEZPhPKrMAAAAAAA==").unwrap(); "cHNidP8AAQD9pQEBAAAAAAECiaPHHqtNIOA3G7ukzGmPopXJRjr6Ljl/hTPMti+VZ+UBAAAAFxYAFL4Y0VKpsBIDna89p95PUzSe7LmF/////4b4qkOnHf8USIk6UwpyN+9rRgi7st0tAXHmOuxqSJC0AQAAABcWABT+Pp7xp0XpdNkCxDVZQ6vLNL1TU/////8CAMLrCwAAAAAZdqkUhc/xCX/Z4Ai7NK9wnGIZeziXikiIrHL++E4sAAAAF6kUM5cluiHv1irHU6m80GfWx6ajnQWHAkcwRAIgJxK+IuAnDzlPVoMR3HyppolwuAJf3TskAinwf4pfOiQCIAGLONfc0xTnNMkna9b7QPZzMlvEuqFEyADS8vAtsnZcASED0uFWdJQbrUqZY3LLh+GFbTZSYG2YVi/jnF6efkE/IQUCSDBFAiEA0SuFLYXc2WHS9fSrZgZU327tzHlMDDPOXMMJ/7X85Y0CIGczio4OFyXBl/saiK9Z9R5E5CVbIBZ8hoQDHAXR8lkqASECI7cr7vCWXRC+B3jv7NYfysb3mk6haTkzgHNEZPhPKrMAAAAAAA==".parse::<Psbt>().unwrap();
} }
#[test] #[test]
@ -1639,7 +1636,7 @@ mod tests {
#[test] #[test]
#[should_panic(expected = "DuplicateKey(Key { type_value: 0, key_data: [] })")] #[should_panic(expected = "DuplicateKey(Key { type_value: 0, key_data: [] })")]
fn invalid_vector_5_base64() { fn invalid_vector_5_base64() {
Psbt::from_str("cHNidP8BAHUCAAAAASaBcTce3/KF6Tet7qSze3gADAVmy7OtZGQXE8pCFxv2AAAAAAD+////AtPf9QUAAAAAGXapFNDFmQPFusKGh2DpD9UhpGZap2UgiKwA4fUFAAAAABepFDVF5uM7gyxHBQ8k0+65PJwDlIvHh7MuEwAAAQD9pQEBAAAAAAECiaPHHqtNIOA3G7ukzGmPopXJRjr6Ljl/hTPMti+VZ+UBAAAAFxYAFL4Y0VKpsBIDna89p95PUzSe7LmF/////4b4qkOnHf8USIk6UwpyN+9rRgi7st0tAXHmOuxqSJC0AQAAABcWABT+Pp7xp0XpdNkCxDVZQ6vLNL1TU/////8CAMLrCwAAAAAZdqkUhc/xCX/Z4Ai7NK9wnGIZeziXikiIrHL++E4sAAAAF6kUM5cluiHv1irHU6m80GfWx6ajnQWHAkcwRAIgJxK+IuAnDzlPVoMR3HyppolwuAJf3TskAinwf4pfOiQCIAGLONfc0xTnNMkna9b7QPZzMlvEuqFEyADS8vAtsnZcASED0uFWdJQbrUqZY3LLh+GFbTZSYG2YVi/jnF6efkE/IQUCSDBFAiEA0SuFLYXc2WHS9fSrZgZU327tzHlMDDPOXMMJ/7X85Y0CIGczio4OFyXBl/saiK9Z9R5E5CVbIBZ8hoQDHAXR8lkqASECI7cr7vCWXRC+B3jv7NYfysb3mk6haTkzgHNEZPhPKrMAAAAAAQA/AgAAAAH//////////////////////////////////////////wAAAAAA/////wEAAAAAAAAAAANqAQAAAAAAAAAA").unwrap(); "cHNidP8BAHUCAAAAASaBcTce3/KF6Tet7qSze3gADAVmy7OtZGQXE8pCFxv2AAAAAAD+////AtPf9QUAAAAAGXapFNDFmQPFusKGh2DpD9UhpGZap2UgiKwA4fUFAAAAABepFDVF5uM7gyxHBQ8k0+65PJwDlIvHh7MuEwAAAQD9pQEBAAAAAAECiaPHHqtNIOA3G7ukzGmPopXJRjr6Ljl/hTPMti+VZ+UBAAAAFxYAFL4Y0VKpsBIDna89p95PUzSe7LmF/////4b4qkOnHf8USIk6UwpyN+9rRgi7st0tAXHmOuxqSJC0AQAAABcWABT+Pp7xp0XpdNkCxDVZQ6vLNL1TU/////8CAMLrCwAAAAAZdqkUhc/xCX/Z4Ai7NK9wnGIZeziXikiIrHL++E4sAAAAF6kUM5cluiHv1irHU6m80GfWx6ajnQWHAkcwRAIgJxK+IuAnDzlPVoMR3HyppolwuAJf3TskAinwf4pfOiQCIAGLONfc0xTnNMkna9b7QPZzMlvEuqFEyADS8vAtsnZcASED0uFWdJQbrUqZY3LLh+GFbTZSYG2YVi/jnF6efkE/IQUCSDBFAiEA0SuFLYXc2WHS9fSrZgZU327tzHlMDDPOXMMJ/7X85Y0CIGczio4OFyXBl/saiK9Z9R5E5CVbIBZ8hoQDHAXR8lkqASECI7cr7vCWXRC+B3jv7NYfysb3mk6haTkzgHNEZPhPKrMAAAAAAQA/AgAAAAH//////////////////////////////////////////wAAAAAA/////wEAAAAAAAAAAANqAQAAAAAAAAAA".parse::<Psbt>().unwrap();
} }
#[test] #[test]
@ -1738,9 +1735,9 @@ mod tests {
#[cfg(feature = "base64")] #[cfg(feature = "base64")]
{ {
let base64str = "cHNidP8BAHUCAAAAASaBcTce3/KF6Tet7qSze3gADAVmy7OtZGQXE8pCFxv2AAAAAAD+////AtPf9QUAAAAAGXapFNDFmQPFusKGh2DpD9UhpGZap2UgiKwA4fUFAAAAABepFDVF5uM7gyxHBQ8k0+65PJwDlIvHh7MuEwAAAQD9pQEBAAAAAAECiaPHHqtNIOA3G7ukzGmPopXJRjr6Ljl/hTPMti+VZ+UBAAAAFxYAFL4Y0VKpsBIDna89p95PUzSe7LmF/////4b4qkOnHf8USIk6UwpyN+9rRgi7st0tAXHmOuxqSJC0AQAAABcWABT+Pp7xp0XpdNkCxDVZQ6vLNL1TU/////8CAMLrCwAAAAAZdqkUhc/xCX/Z4Ai7NK9wnGIZeziXikiIrHL++E4sAAAAF6kUM5cluiHv1irHU6m80GfWx6ajnQWHAkcwRAIgJxK+IuAnDzlPVoMR3HyppolwuAJf3TskAinwf4pfOiQCIAGLONfc0xTnNMkna9b7QPZzMlvEuqFEyADS8vAtsnZcASED0uFWdJQbrUqZY3LLh+GFbTZSYG2YVi/jnF6efkE/IQUCSDBFAiEA0SuFLYXc2WHS9fSrZgZU327tzHlMDDPOXMMJ/7X85Y0CIGczio4OFyXBl/saiK9Z9R5E5CVbIBZ8hoQDHAXR8lkqASECI7cr7vCWXRC+B3jv7NYfysb3mk6haTkzgHNEZPhPKrMAAAAAAAAA"; let base64str = "cHNidP8BAHUCAAAAASaBcTce3/KF6Tet7qSze3gADAVmy7OtZGQXE8pCFxv2AAAAAAD+////AtPf9QUAAAAAGXapFNDFmQPFusKGh2DpD9UhpGZap2UgiKwA4fUFAAAAABepFDVF5uM7gyxHBQ8k0+65PJwDlIvHh7MuEwAAAQD9pQEBAAAAAAECiaPHHqtNIOA3G7ukzGmPopXJRjr6Ljl/hTPMti+VZ+UBAAAAFxYAFL4Y0VKpsBIDna89p95PUzSe7LmF/////4b4qkOnHf8USIk6UwpyN+9rRgi7st0tAXHmOuxqSJC0AQAAABcWABT+Pp7xp0XpdNkCxDVZQ6vLNL1TU/////8CAMLrCwAAAAAZdqkUhc/xCX/Z4Ai7NK9wnGIZeziXikiIrHL++E4sAAAAF6kUM5cluiHv1irHU6m80GfWx6ajnQWHAkcwRAIgJxK+IuAnDzlPVoMR3HyppolwuAJf3TskAinwf4pfOiQCIAGLONfc0xTnNMkna9b7QPZzMlvEuqFEyADS8vAtsnZcASED0uFWdJQbrUqZY3LLh+GFbTZSYG2YVi/jnF6efkE/IQUCSDBFAiEA0SuFLYXc2WHS9fSrZgZU327tzHlMDDPOXMMJ/7X85Y0CIGczio4OFyXBl/saiK9Z9R5E5CVbIBZ8hoQDHAXR8lkqASECI7cr7vCWXRC+B3jv7NYfysb3mk6haTkzgHNEZPhPKrMAAAAAAAAA";
assert_eq!(Psbt::from_str(base64str).unwrap(), unserialized); assert_eq!(base64str.parse::<Psbt>().unwrap(), unserialized);
assert_eq!(base64str, unserialized.to_string()); assert_eq!(base64str, unserialized.to_string());
assert_eq!(Psbt::from_str(base64str).unwrap(), hex_psbt(base16str).unwrap()); assert_eq!(base64str.parse::<Psbt>().unwrap(), hex_psbt(base16str).unwrap());
} }
} }

4
bitcoin/src/sign_message.rs
View File

@ -222,8 +222,6 @@ mod tests {
#[test] #[test]
#[cfg(all(feature = "secp-recovery", feature = "base64", feature = "rand-std"))] #[cfg(all(feature = "secp-recovery", feature = "base64", feature = "rand-std"))]
fn test_message_signature() { fn test_message_signature() {
use core::str::FromStr;
use secp256k1; use secp256k1;
use crate::{Address, AddressType, Network, NetworkKind}; use crate::{Address, AddressType, Network, NetworkKind};
@ -237,7 +235,7 @@ mod tests {
let signature = super::MessageSignature { signature: secp_sig, compressed: true }; let signature = super::MessageSignature { signature: secp_sig, compressed: true };
assert_eq!(signature.to_base64(), signature.to_string()); assert_eq!(signature.to_base64(), signature.to_string());
let signature2 = super::MessageSignature::from_str(&signature.to_string()).unwrap(); let signature2 = &signature.to_string().parse::<super::MessageSignature>().unwrap();
let pubkey = signature2 let pubkey = signature2
.recover_pubkey(&secp, msg_hash) .recover_pubkey(&secp, msg_hash)
.unwrap() .unwrap()

45
bitcoin/src/taproot/mod.rs
View File

@ -1545,8 +1545,6 @@ impl std::error::Error for InvalidControlBlockSizeError {}
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use core::str::FromStr;
use hashes::sha256; use hashes::sha256;
use hashes::sha256t::Tag; use hashes::sha256t::Tag;
use hex::{DisplayHex, FromHex}; use hex::{DisplayHex, FromHex};
@ -1648,7 +1646,7 @@ mod test {
script_hex: &str, script_hex: &str,
control_block_hex: &str, control_block_hex: &str,
) { ) {
let out_pk = XOnlyPublicKey::from_str(&out_spk_hex[4..]).unwrap(); let out_pk = out_spk_hex[4..].parse::<XOnlyPublicKey>().unwrap();
let out_pk = TweakedPublicKey::dangerous_assume_tweaked(out_pk); let out_pk = TweakedPublicKey::dangerous_assume_tweaked(out_pk);
let script = ScriptBuf::from_hex(script_hex).unwrap(); let script = ScriptBuf::from_hex(script_hex).unwrap();
let control_block = let control_block =
@ -1712,10 +1710,9 @@ mod test {
#[test] #[test]
fn build_huffman_tree() { fn build_huffman_tree() {
let secp = Secp256k1::verification_only(); let secp = Secp256k1::verification_only();
let internal_key = UntweakedPublicKey::from_str( let internal_key = "93c7378d96518a75448821c4f7c8f4bae7ce60f804d03d1f0628dd5dd0f5de51"
"93c7378d96518a75448821c4f7c8f4bae7ce60f804d03d1f0628dd5dd0f5de51", .parse::<UntweakedPublicKey>()
) .unwrap();
.unwrap();
let script_weights = [ let script_weights = [
(10, ScriptBuf::from_hex("51").unwrap()), // semantics of script don't matter for this test (10, ScriptBuf::from_hex("51").unwrap()), // semantics of script don't matter for this test
@ -1770,10 +1767,9 @@ mod test {
#[test] #[test]
fn taptree_builder() { fn taptree_builder() {
let secp = Secp256k1::verification_only(); let secp = Secp256k1::verification_only();
let internal_key = UntweakedPublicKey::from_str( let internal_key = "93c7378d96518a75448821c4f7c8f4bae7ce60f804d03d1f0628dd5dd0f5de51"
"93c7378d96518a75448821c4f7c8f4bae7ce60f804d03d1f0628dd5dd0f5de51", .parse::<UntweakedPublicKey>()
) .unwrap();
.unwrap();
let builder = TaprootBuilder::new(); let builder = TaprootBuilder::new();
// Create a tree as shown below // Create a tree as shown below
@ -1905,7 +1901,7 @@ mod test {
for arr in data["scriptPubKey"].as_array().unwrap() { for arr in data["scriptPubKey"].as_array().unwrap() {
let internal_key = let internal_key =
XOnlyPublicKey::from_str(arr["given"]["internalPubkey"].as_str().unwrap()).unwrap(); arr["given"]["internalPubkey"].as_str().unwrap().parse::<XOnlyPublicKey>().unwrap();
// process the tree // process the tree
let script_tree = &arr["given"]["scriptTree"]; let script_tree = &arr["given"]["scriptTree"];
let mut merkle_root = None; let mut merkle_root = None;
@ -1913,7 +1909,10 @@ mod test {
assert!(arr["intermediary"]["merkleRoot"].is_null()); assert!(arr["intermediary"]["merkleRoot"].is_null());
} else { } else {
merkle_root = Some( merkle_root = Some(
TapNodeHash::from_str(arr["intermediary"]["merkleRoot"].as_str().unwrap()) arr["intermediary"]["merkleRoot"]
.as_str()
.unwrap()
.parse::<TapNodeHash>()
.unwrap(), .unwrap(),
); );
let leaf_hashes = arr["intermediary"]["leafHashes"].as_array().unwrap(); let leaf_hashes = arr["intermediary"]["leafHashes"].as_array().unwrap();
@ -1935,17 +1934,21 @@ mod test {
assert_eq!(ctrl_blk, expected_ctrl_blk); assert_eq!(ctrl_blk, expected_ctrl_blk);
} }
} }
let expected_output_key = let expected_output_key = arr["intermediary"]["tweakedPubkey"]
XOnlyPublicKey::from_str(arr["intermediary"]["tweakedPubkey"].as_str().unwrap()) .as_str()
.unwrap(); .unwrap()
.parse::<XOnlyPublicKey>()
.unwrap();
let expected_tweak = let expected_tweak =
TapTweakHash::from_str(arr["intermediary"]["tweak"].as_str().unwrap()).unwrap(); arr["intermediary"]["tweak"].as_str().unwrap().parse::<TapTweakHash>().unwrap();
let expected_spk = let expected_spk =
ScriptBuf::from_hex(arr["expected"]["scriptPubKey"].as_str().unwrap()).unwrap(); ScriptBuf::from_hex(arr["expected"]["scriptPubKey"].as_str().unwrap()).unwrap();
let expected_addr = let expected_addr = arr["expected"]["bip350Address"]
Address::from_str(arr["expected"]["bip350Address"].as_str().unwrap()) .as_str()
.unwrap() .unwrap()
.assume_checked(); .parse::<Address<_>>()
.unwrap()
.assume_checked();
let tweak = TapTweakHash::from_key_and_tweak(internal_key, merkle_root); let tweak = TapTweakHash::from_key_and_tweak(internal_key, merkle_root);
let (output_key, _parity) = internal_key.tap_tweak(secp, merkle_root); let (output_key, _parity) = internal_key.tap_tweak(secp, merkle_root);

19
bitcoin/tests/psbt-sign-taproot.rs
View File

@ -1,7 +1,6 @@
#![cfg(not(feature = "rand-std"))] #![cfg(not(feature = "rand-std"))]
use std::collections::BTreeMap; use std::collections::BTreeMap;
use std::str::FromStr;
use bitcoin::bip32::{DerivationPath, Fingerprint}; use bitcoin::bip32::{DerivationPath, Fingerprint};
use bitcoin::consensus::encode::serialize_hex; use bitcoin::consensus::encode::serialize_hex;
@ -77,7 +76,7 @@ fn psbt_sign_taproot() {
// m/86'/1'/0'/0/7 // m/86'/1'/0'/0/7
let to_address = "tb1pyfv094rr0vk28lf8v9yx3veaacdzg26ztqk4ga84zucqqhafnn5q9my9rz"; let to_address = "tb1pyfv094rr0vk28lf8v9yx3veaacdzg26ztqk4ga84zucqqhafnn5q9my9rz";
let to_address = Address::from_str(to_address).unwrap().assume_checked(); let to_address = to_address.parse::<Address<_>>().unwrap().assume_checked();
// key path spend // key path spend
{ {
@ -94,7 +93,7 @@ fn psbt_sign_taproot() {
// Step 2: sign psbt. // Step 2: sign psbt.
// //
let keystore = Keystore { let keystore = Keystore {
mfp: Fingerprint::from_str(mfp).unwrap(), mfp: mfp.parse::<Fingerprint>().unwrap(),
sk: PrivateKey::new(kp.secret_key(), Network::Testnet), sk: PrivateKey::new(kp.secret_key(), Network::Testnet),
}; };
let _ = psbt_key_path_spend.sign(&keystore, secp); let _ = psbt_key_path_spend.sign(&keystore, secp);
@ -124,7 +123,7 @@ fn psbt_sign_taproot() {
let signing_key_path = sk_path[1].1; let signing_key_path = sk_path[1].1;
let keystore = Keystore { let keystore = Keystore {
mfp: Fingerprint::from_str(mfp).unwrap(), mfp: mfp.parse::<Fingerprint>().unwrap(),
sk: PrivateKey::new(kp.secret_key(), Network::Testnet), sk: PrivateKey::new(kp.secret_key(), Network::Testnet),
}; };
@ -234,8 +233,8 @@ fn create_psbt_for_taproot_key_path_spend(
( (
vec![], vec![],
( (
Fingerprint::from_str(mfp).unwrap(), mfp.parse::<Fingerprint>().unwrap(),
DerivationPath::from_str(internal_key_path).unwrap(), internal_key_path.parse::<DerivationPath>().unwrap(),
), ),
), ),
); );
@ -249,7 +248,7 @@ fn create_psbt_for_taproot_key_path_spend(
tap_key_origins: origins, tap_key_origins: origins,
..Default::default() ..Default::default()
}; };
let ty = PsbtSighashType::from_str("SIGHASH_DEFAULT").unwrap(); let ty = "SIGHASH_DEFAULT".parse::<PsbtSighashType>().unwrap();
input.sighash_type = Some(ty); input.sighash_type = Some(ty);
input.tap_internal_key = Some(tree.internal_key()); input.tap_internal_key = Some(tree.internal_key());
input.tap_merkle_root = tree.merkle_root(); input.tap_merkle_root = tree.merkle_root();
@ -308,8 +307,8 @@ fn create_psbt_for_taproot_script_path_spend(
( (
vec![use_script.tapscript_leaf_hash()], vec![use_script.tapscript_leaf_hash()],
( (
Fingerprint::from_str(mfp).unwrap(), mfp.parse::<Fingerprint>().unwrap(),
DerivationPath::from_str(signing_key_path).unwrap(), signing_key_path.parse::<DerivationPath>().unwrap(),
), ),
), ),
); );
@ -329,7 +328,7 @@ fn create_psbt_for_taproot_script_path_spend(
tap_scripts, tap_scripts,
..Default::default() ..Default::default()
}; };
let ty = PsbtSighashType::from_str("SIGHASH_ALL").unwrap(); let ty = "SIGHASH_ALL".parse::<PsbtSighashType>().unwrap();
input.sighash_type = Some(ty); input.sighash_type = Some(ty);
input.tap_internal_key = Some(tree.internal_key()); input.tap_internal_key = Some(tree.internal_key());
input.tap_merkle_root = tree.merkle_root(); input.tap_merkle_root = tree.merkle_root();

17
bitcoin/tests/serde.rs
View File

@ -23,7 +23,6 @@
#![cfg(feature = "serde")] #![cfg(feature = "serde")]
use std::collections::BTreeMap; use std::collections::BTreeMap;
use std::str::FromStr;
use bincode::serialize; use bincode::serialize;
use bitcoin::bip32::{ChildNumber, KeySource, Xpriv, Xpub}; use bitcoin::bip32::{ChildNumber, KeySource, Xpriv, Xpub};
@ -144,7 +143,7 @@ fn serde_regression_witness() {
#[test] #[test]
fn serde_regression_address() { fn serde_regression_address() {
let s = include_str!("data/serde/public_key_hex"); let s = include_str!("data/serde/public_key_hex");
let pk = PublicKey::from_str(s.trim()).unwrap(); let pk = s.trim().parse::<PublicKey>().unwrap();
let addr = Address::p2pkh(pk, NetworkKind::Main); let addr = Address::p2pkh(pk, NetworkKind::Main);
let got = serialize(&addr).unwrap(); let got = serialize(&addr).unwrap();
@ -155,7 +154,7 @@ fn serde_regression_address() {
#[test] #[test]
fn serde_regression_extended_priv_key() { fn serde_regression_extended_priv_key() {
let s = include_str!("data/serde/extended_priv_key"); let s = include_str!("data/serde/extended_priv_key");
let key = Xpriv::from_str(s.trim()).unwrap(); let key = s.trim().parse::<Xpriv>().unwrap();
let got = serialize(&key).unwrap(); let got = serialize(&key).unwrap();
let want = include_bytes!("data/serde/extended_priv_key_bincode") as &[_]; let want = include_bytes!("data/serde/extended_priv_key_bincode") as &[_];
assert_eq!(got, want) assert_eq!(got, want)
@ -164,7 +163,7 @@ fn serde_regression_extended_priv_key() {
#[test] #[test]
fn serde_regression_extended_pub_key() { fn serde_regression_extended_pub_key() {
let s = include_str!("data/serde/extended_pub_key"); let s = include_str!("data/serde/extended_pub_key");
let key = Xpub::from_str(s.trim()).unwrap(); let key = s.trim().parse::<Xpub>().unwrap();
let got = serialize(&key).unwrap(); let got = serialize(&key).unwrap();
let want = include_bytes!("data/serde/extended_pub_key_bincode") as &[_]; let want = include_bytes!("data/serde/extended_pub_key_bincode") as &[_];
assert_eq!(got, want) assert_eq!(got, want)
@ -174,7 +173,7 @@ fn serde_regression_extended_pub_key() {
fn serde_regression_ecdsa_sig() { fn serde_regression_ecdsa_sig() {
let s = include_str!("data/serde/ecdsa_sig_hex"); let s = include_str!("data/serde/ecdsa_sig_hex");
let sig = ecdsa::Signature { let sig = ecdsa::Signature {
signature: secp256k1::ecdsa::Signature::from_str(s.trim()).unwrap(), signature: s.trim().parse::<secp256k1::ecdsa::Signature>().unwrap(),
sighash_type: EcdsaSighashType::All, sighash_type: EcdsaSighashType::All,
}; };
@ -212,7 +211,7 @@ fn serde_regression_private_key() {
#[test] #[test]
fn serde_regression_public_key() { fn serde_regression_public_key() {
let s = include_str!("data/serde/public_key_hex"); let s = include_str!("data/serde/public_key_hex");
let pk = PublicKey::from_str(s.trim()).unwrap(); let pk = s.trim().parse::<PublicKey>().unwrap();
let got = serialize(&pk).unwrap(); let got = serialize(&pk).unwrap();
let want = include_bytes!("data/serde/public_key_bincode") as &[_]; let want = include_bytes!("data/serde/public_key_bincode") as &[_];
assert_eq!(got, want) assert_eq!(got, want)
@ -271,7 +270,7 @@ fn serde_regression_psbt() {
version: 0, version: 0,
xpub: { xpub: {
let s = include_str!("data/serde/extended_pub_key"); let s = include_str!("data/serde/extended_pub_key");
let xpub = Xpub::from_str(s.trim()).unwrap(); let xpub = s.trim().parse::<Xpub>().unwrap();
vec![(xpub, key_source)].into_iter().collect() vec![(xpub, key_source)].into_iter().collect()
}, },
unsigned_tx: { unsigned_tx: {
@ -289,7 +288,7 @@ fn serde_regression_psbt() {
value: Amount::from_sat(190_303_501_938), value: Amount::from_sat(190_303_501_938),
script_pubkey: ScriptBuf::from_hex("a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587").unwrap(), script_pubkey: ScriptBuf::from_hex("a914339725ba21efd62ac753a9bcd067d6c7a6a39d0587").unwrap(),
}), }),
sighash_type: Some(PsbtSighashType::from(EcdsaSighashType::from_str("SIGHASH_SINGLE|SIGHASH_ANYONECANPAY").unwrap())), sighash_type: Some(PsbtSighashType::from("SIGHASH_SINGLE|SIGHASH_ANYONECANPAY".parse::<EcdsaSighashType>().unwrap())),
redeem_script: Some(vec![0x51].into()), redeem_script: Some(vec![0x51].into()),
witness_script: None, witness_script: None,
partial_sigs: vec![( partial_sigs: vec![(
@ -350,7 +349,7 @@ fn serde_regression_proprietary_key() {
fn serde_regression_taproot_sig() { fn serde_regression_taproot_sig() {
let s = include_str!("data/serde/taproot_sig_hex"); let s = include_str!("data/serde/taproot_sig_hex");
let sig = taproot::Signature { let sig = taproot::Signature {
signature: secp256k1::schnorr::Signature::from_str(s.trim()).unwrap(), signature: s.trim().parse::<secp256k1::schnorr::Signature>().unwrap(),
sighash_type: TapSighashType::All, sighash_type: TapSighashType::All,
}; };

4
fuzz/fuzz_targets/bitcoin/deserialize_address.rs
View File

@ -1,10 +1,8 @@
use std::str::FromStr;
use honggfuzz::fuzz; use honggfuzz::fuzz;
fn do_test(data: &[u8]) { fn do_test(data: &[u8]) {
let data_str = String::from_utf8_lossy(data); let data_str = String::from_utf8_lossy(data);
let addr = match bitcoin::address::Address::from_str(&data_str) { let addr = match data_str.parse::<bitcoin::address::Address<_>>() {
Ok(addr) => addr.assume_checked(), Ok(addr) => addr.assume_checked(),
Err(_) => return, Err(_) => return,
}; };

6
fuzz/fuzz_targets/bitcoin/outpoint_string.rs
View File

@ -1,5 +1,3 @@
use std::str::FromStr;
use bitcoin::consensus::encode; use bitcoin::consensus::encode;
use bitcoin::transaction::OutPoint; use bitcoin::transaction::OutPoint;
use honggfuzz::fuzz; use honggfuzz::fuzz;
@ -21,7 +19,7 @@ fn do_test(data: &[u8]) {
Err(_) => return, Err(_) => return,
Ok(s) => s, Ok(s) => s,
}; };
match OutPoint::from_str(&data_str) { match data_str.parse::<OutPoint>() {
Ok(op) => { Ok(op) => {
assert_eq!(op.to_string().as_bytes(), data_str.as_bytes()); assert_eq!(op.to_string().as_bytes(), data_str.as_bytes());
} }
@ -32,7 +30,7 @@ fn do_test(data: &[u8]) {
let ser = encode::serialize(&deser); let ser = encode::serialize(&deser);
assert_eq!(ser, data); assert_eq!(ser, data);
let string = deser.to_string(); let string = deser.to_string();
match OutPoint::from_str(&string) { match string.parse::<OutPoint>() {
Ok(destring) => assert_eq!(destring, deser), Ok(destring) => assert_eq!(destring, deser),
Err(_) => panic!(), Err(_) => panic!(),
} }

10
fuzz/fuzz_targets/units/deserialize_amount.rs
View File

@ -1,27 +1,25 @@
use std::str::FromStr;
use honggfuzz::fuzz; use honggfuzz::fuzz;
fn do_test(data: &[u8]) { fn do_test(data: &[u8]) {
let data_str = String::from_utf8_lossy(data); let data_str = String::from_utf8_lossy(data);
// signed // signed
let samt = match bitcoin::amount::SignedAmount::from_str(&data_str) { let samt = match data_str.parse::<bitcoin::amount::SignedAmount>() {
Ok(amt) => amt, Ok(amt) => amt,
Err(_) => return, Err(_) => return,
}; };
let samt_roundtrip = match bitcoin::amount::SignedAmount::from_str(&samt.to_string()) { let samt_roundtrip = match samt.to_string().parse::<bitcoin::amount::SignedAmount>() {
Ok(amt) => amt, Ok(amt) => amt,
Err(_) => return, Err(_) => return,
}; };
assert_eq!(samt, samt_roundtrip); assert_eq!(samt, samt_roundtrip);
// unsigned // unsigned
let amt = match bitcoin::amount::Amount::from_str(&data_str) { let amt = match data_str.parse::<bitcoin::amount::Amount>() {
Ok(amt) => amt, Ok(amt) => amt,
Err(_) => return, Err(_) => return,
}; };
let amt_roundtrip = match bitcoin::amount::Amount::from_str(&amt.to_string()) { let amt_roundtrip = match amt.to_string().parse::<bitcoin::amount::Amount>() {
Ok(amt) => amt, Ok(amt) => amt,
Err(_) => return, Err(_) => return,
}; };

52
units/src/amount.rs
View File

@ -2046,21 +2046,21 @@ mod tests {
for denom in denoms { for denom in denoms {
for v in &["0", "000"] { for v in &["0", "000"] {
let s = format!("{} {}", v, denom); let s = format!("{} {}", v, denom);
match Amount::from_str(&s) { match s.parse::<Amount>() {
Err(e) => panic!("failed to crate amount from {}: {:?}", s, e), Err(e) => panic!("failed to crate amount from {}: {:?}", s, e),
Ok(amount) => assert_eq!(amount, Amount::from_sat(0)), Ok(amount) => assert_eq!(amount, Amount::from_sat(0)),
} }
} }
let s = format!("-0 {}", denom); let s = format!("-0 {}", denom);
match Amount::from_str(&s) { match s.parse::<Amount>() {
Err(e) => assert_eq!( Err(e) => assert_eq!(
e, e,
ParseError::Amount(ParseAmountError::OutOfRange(OutOfRangeError::negative())) ParseError::Amount(ParseAmountError::OutOfRange(OutOfRangeError::negative()))
), ),
Ok(_) => panic!("unsigned amount from {}", s), Ok(_) => panic!("unsigned amount from {}", s),
} }
match SignedAmount::from_str(&s) { match s.parse::<SignedAmount>() {
Err(e) => panic!("failed to crate amount from {}: {:?}", s, e), Err(e) => panic!("failed to crate amount from {}: {:?}", s, e),
Ok(amount) => assert_eq!(amount, SignedAmount::from_sat(0)), Ok(amount) => assert_eq!(amount, SignedAmount::from_sat(0)),
} }
@ -2514,50 +2514,50 @@ mod tests {
use super::ParseAmountError as E; use super::ParseAmountError as E;
assert_eq!( assert_eq!(
Amount::from_str("x BTC"), "x BTC".parse::<Amount>(),
Err(InvalidCharacterError { invalid_char: 'x', position: 0 }.into()) Err(InvalidCharacterError { invalid_char: 'x', position: 0 }.into())
); );
assert_eq!( assert_eq!(
Amount::from_str("xBTC"), "xBTC".parse::<Amount>(),
Err(Unknown(UnknownDenominationError("xBTC".into())).into()), Err(Unknown(UnknownDenominationError("xBTC".into())).into()),
); );
assert_eq!( assert_eq!(
Amount::from_str("5 BTC BTC"), "5 BTC BTC".parse::<Amount>(),
Err(Unknown(UnknownDenominationError("BTC BTC".into())).into()), Err(Unknown(UnknownDenominationError("BTC BTC".into())).into()),
); );
assert_eq!( assert_eq!(
Amount::from_str("5BTC BTC"), "5BTC BTC".parse::<Amount>(),
Err(E::from(InvalidCharacterError { invalid_char: 'B', position: 1 }).into()) Err(E::from(InvalidCharacterError { invalid_char: 'B', position: 1 }).into())
); );
assert_eq!( assert_eq!(
Amount::from_str("5 5 BTC"), "5 5 BTC".parse::<Amount>(),
Err(Unknown(UnknownDenominationError("5 BTC".into())).into()), Err(Unknown(UnknownDenominationError("5 BTC".into())).into()),
); );
#[track_caller] #[track_caller]
fn ok_case(s: &str, expected: Amount) { fn ok_case(s: &str, expected: Amount) {
assert_eq!(Amount::from_str(s).unwrap(), expected); assert_eq!(s.parse::<Amount>().unwrap(), expected);
assert_eq!(Amount::from_str(&s.replace(' ', "")).unwrap(), expected); assert_eq!(s.replace(' ', "").parse::<Amount>().unwrap(), expected);
} }
#[track_caller] #[track_caller]
fn case(s: &str, expected: Result<Amount, impl Into<ParseError>>) { fn case(s: &str, expected: Result<Amount, impl Into<ParseError>>) {
let expected = expected.map_err(Into::into); let expected = expected.map_err(Into::into);
assert_eq!(Amount::from_str(s), expected); assert_eq!(s.parse::<Amount>(), expected);
assert_eq!(Amount::from_str(&s.replace(' ', "")), expected); assert_eq!(s.replace(' ', "").parse::<Amount>(), expected);
} }
#[track_caller] #[track_caller]
fn ok_scase(s: &str, expected: SignedAmount) { fn ok_scase(s: &str, expected: SignedAmount) {
assert_eq!(SignedAmount::from_str(s).unwrap(), expected); assert_eq!(s.parse::<SignedAmount>().unwrap(), expected);
assert_eq!(SignedAmount::from_str(&s.replace(' ', "")).unwrap(), expected); assert_eq!(s.replace(' ', "").parse::<SignedAmount>().unwrap(), expected);
} }
#[track_caller] #[track_caller]
fn scase(s: &str, expected: Result<SignedAmount, impl Into<ParseError>>) { fn scase(s: &str, expected: Result<SignedAmount, impl Into<ParseError>>) {
let expected = expected.map_err(Into::into); let expected = expected.map_err(Into::into);
assert_eq!(SignedAmount::from_str(s), expected); assert_eq!(s.parse::<SignedAmount>(), expected);
assert_eq!(SignedAmount::from_str(&s.replace(' ', "")), expected); assert_eq!(s.replace(' ', "").parse::<SignedAmount>(), expected);
} }
case("5 BCH", Err(Unknown(UnknownDenominationError("BCH".into())))); case("5 BCH", Err(Unknown(UnknownDenominationError("BCH".into()))));
@ -2647,18 +2647,18 @@ mod tests {
let amt = Amount::from_sat(42); let amt = Amount::from_sat(42);
let denom = Amount::to_string_with_denomination; let denom = Amount::to_string_with_denomination;
assert_eq!(Amount::from_str(&denom(amt, D::Bitcoin)), Ok(amt)); assert_eq!(denom(amt, D::Bitcoin).parse::<Amount>(), Ok(amt));
assert_eq!(Amount::from_str(&denom(amt, D::MilliBitcoin)), Ok(amt)); assert_eq!(denom(amt, D::MilliBitcoin).parse::<Amount>(), Ok(amt));
assert_eq!(Amount::from_str(&denom(amt, D::MicroBitcoin)), Ok(amt)); assert_eq!(denom(amt, D::MicroBitcoin).parse::<Amount>(), Ok(amt));
assert_eq!(Amount::from_str(&denom(amt, D::Bit)), Ok(amt)); assert_eq!(denom(amt, D::Bit).parse::<Amount>(), Ok(amt));
assert_eq!(Amount::from_str(&denom(amt, D::Satoshi)), Ok(amt)); assert_eq!(denom(amt, D::Satoshi).parse::<Amount>(), Ok(amt));
assert_eq!( assert_eq!(
Amount::from_str("42 satoshi BTC"), "42 satoshi BTC".parse::<Amount>(),
Err(Unknown(UnknownDenominationError("satoshi BTC".into())).into()), Err(Unknown(UnknownDenominationError("satoshi BTC".into())).into()),
); );
assert_eq!( assert_eq!(
SignedAmount::from_str("-42 satoshi BTC"), "-42 satoshi BTC".parse::<SignedAmount>(),
Err(Unknown(UnknownDenominationError("satoshi BTC".into())).into()), Err(Unknown(UnknownDenominationError("satoshi BTC".into())).into()),
); );
} }
@ -2868,7 +2868,7 @@ mod tests {
"satoshis", "SAT", "sat", "SATS", "sats", "bit", "bits", "satoshis", "SAT", "sat", "SATS", "sats", "bit", "bits",
]; ];
for denom in valid.iter() { for denom in valid.iter() {
assert!(Denomination::from_str(denom).is_ok()); assert!(denom.parse::<Denomination>().is_ok());
} }
} }
@ -2876,7 +2876,7 @@ mod tests {
fn disallow_confusing_forms() { fn disallow_confusing_forms() {
let confusing = ["CBTC", "Cbtc", "MBTC", "Mbtc", "UBTC", "Ubtc"]; let confusing = ["CBTC", "Cbtc", "MBTC", "Mbtc", "UBTC", "Ubtc"];
for denom in confusing.iter() { for denom in confusing.iter() {
match Denomination::from_str(denom) { match denom.parse::<Denomination>() {
Ok(_) => panic!("from_str should error for {}", denom), Ok(_) => panic!("from_str should error for {}", denom),
Err(ParseDenominationError::PossiblyConfusing(_)) => {} Err(ParseDenominationError::PossiblyConfusing(_)) => {}
Err(e) => panic!("unexpected error: {}", e), Err(e) => panic!("unexpected error: {}", e),
@ -2889,7 +2889,7 @@ mod tests {
// Non-exhaustive list of unknown forms. // Non-exhaustive list of unknown forms.
let unknown = ["NBTC", "ABC", "abc", "mSat", "msat"]; let unknown = ["NBTC", "ABC", "abc", "mSat", "msat"];
for denom in unknown.iter() { for denom in unknown.iter() {
match Denomination::from_str(denom) { match denom.parse::<Denomination>() {
Ok(_) => panic!("from_str should error for {}", denom), Ok(_) => panic!("from_str should error for {}", denom),
Err(ParseDenominationError::Unknown(_)) => (), Err(ParseDenominationError::Unknown(_)) => (),
Err(e) => panic!("unexpected error: {}", e), Err(e) => panic!("unexpected error: {}", e),