// Rust Bitcoin Library // Written in 2014 by // Andrew Poelstra // To the extent possible under law, the author(s) have dedicated all // copyright and related and neighboring rights to this software to // the public domain worldwide. This software is distributed without // any warranty. // // You should have received a copy of the CC0 Public Domain Dedication // along with this software. // If not, see . // //! Addresses //! //! Support for ordinary base58 Bitcoin addresses and private keys //! //! # Example: creating a new address from a randomly-generated key pair //! //! ```rust //! //! use bitcoin::network::constants::Network; //! use bitcoin::util::address::Address; //! use bitcoin::util::ecdsa; //! use bitcoin::secp256k1::Secp256k1; //! use bitcoin::secp256k1::rand::thread_rng; //! //! // Generate random key pair //! let s = Secp256k1::new(); //! let public_key = ecdsa::PublicKey::new(s.generate_keypair(&mut thread_rng()).1); //! //! // Generate pay-to-pubkey-hash address //! let address = Address::p2pkh(&public_key, Network::Bitcoin); //! ``` use prelude::*; use core::fmt; use core::str::FromStr; #[cfg(feature = "std")] use std::error; use bech32; use hashes::Hash; use hash_types::{PubkeyHash, WPubkeyHash, ScriptHash, WScriptHash}; use blockdata::script; use network::constants::Network; use util::base58; use util::ecdsa; /// Address error. #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash, Clone)] pub enum Error { /// Base58 encoding error Base58(base58::Error), /// Bech32 encoding error Bech32(bech32::Error), /// The bech32 payload was empty EmptyBech32Payload, /// Script version must be 0 to 16 inclusive InvalidWitnessVersion(u8), /// The witness program must be between 2 and 40 bytes in length. InvalidWitnessProgramLength(usize), /// A v0 witness program must be either of length 20 or 32. InvalidSegwitV0ProgramLength(usize), /// An uncompressed pubkey was used where it is not allowed. UncompressedPubkey, } impl fmt::Display for Error { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { match *self { Error::Base58(ref e) => write!(f, "base58: {}", e), Error::Bech32(ref e) => write!(f, "bech32: {}", e), Error::EmptyBech32Payload => write!(f, "the bech32 payload was empty"), Error::InvalidWitnessVersion(v) => write!(f, "invalid witness script version: {}", v), Error::InvalidWitnessProgramLength(l) => write!(f, "the witness program must be between 2 and 40 bytes in length: length={}", l, ), Error::InvalidSegwitV0ProgramLength(l) => write!(f, "a v0 witness program must be either of length 20 or 32 bytes: length={}", l, ), Error::UncompressedPubkey => write!(f, "an uncompressed pubkey was used where it is not allowed", ), } } } #[cfg(feature = "std")] impl ::std::error::Error for Error { fn cause(&self) -> Option<&dyn error::Error> { match *self { Error::Base58(ref e) => Some(e), Error::Bech32(ref e) => Some(e), _ => None, } } } #[doc(hidden)] impl From for Error { fn from(e: base58::Error) -> Error { Error::Base58(e) } } #[doc(hidden)] impl From for Error { fn from(e: bech32::Error) -> Error { Error::Bech32(e) } } /// The different types of addresses. #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)] pub enum AddressType { /// pay-to-pubkey-hash P2pkh, /// pay-to-script-hash P2sh, /// pay-to-witness-pubkey-hash P2wpkh, /// pay-to-witness-script-hash P2wsh, } impl fmt::Display for AddressType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str(match *self { AddressType::P2pkh => "p2pkh", AddressType::P2sh => "p2sh", AddressType::P2wpkh => "p2wpkh", AddressType::P2wsh => "p2wsh", }) } } impl FromStr for AddressType { type Err = (); fn from_str(s: &str) -> Result { match s { "p2pkh" => Ok(AddressType::P2pkh), "p2sh" => Ok(AddressType::P2sh), "p2wpkh" => Ok(AddressType::P2wpkh), "p2wsh" => Ok(AddressType::P2wsh), _ => Err(()), } } } /// The method used to produce an address #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] pub enum Payload { /// P2PKH address PubkeyHash(PubkeyHash), /// P2SH address ScriptHash(ScriptHash), /// Segwit addresses WitnessProgram { /// The witness program version version: bech32::u5, /// The witness program program: Vec, }, } impl Payload { /// Get a [Payload] from an output script (scriptPubkey). pub fn from_script(script: &script::Script) -> Option { Some(if script.is_p2pkh() { Payload::PubkeyHash(PubkeyHash::from_slice(&script.as_bytes()[3..23]).unwrap()) } else if script.is_p2sh() { Payload::ScriptHash(ScriptHash::from_slice(&script.as_bytes()[2..22]).unwrap()) } else if script.is_witness_program() { // We can unwrap the u5 check and assume script length // because [Script::is_witness_program] makes sure of this. Payload::WitnessProgram { version: { // Since we passed the [is_witness_program] check, // the first byte is either 0x00 or 0x50 + version. let mut verop = script.as_bytes()[0]; if verop > 0x50 { verop -= 0x50; } bech32::u5::try_from_u8(verop).expect("checked before") }, program: script.as_bytes()[2..].to_vec(), } } else { return None; }) } /// Generates a script pubkey spending to this [Payload]. pub fn script_pubkey(&self) -> script::Script { match *self { Payload::PubkeyHash(ref hash) => script::Script::new_p2pkh(hash), Payload::ScriptHash(ref hash) => script::Script::new_p2sh(hash), Payload::WitnessProgram { version: ver, program: ref prog, } => script::Script::new_witness_program(ver, prog) } } } #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)] /// A Bitcoin address pub struct Address { /// The type of the address pub payload: Payload, /// The network on which this address is usable pub network: Network, } serde_string_impl!(Address, "a Bitcoin address"); impl Address { /// Creates a pay to (compressed) public key hash address from a public key /// This is the preferred non-witness type address #[inline] pub fn p2pkh(pk: &ecdsa::PublicKey, network: Network) -> Address { let mut hash_engine = PubkeyHash::engine(); pk.write_into(&mut hash_engine).expect("engines don't error"); Address { network: network, payload: Payload::PubkeyHash(PubkeyHash::from_engine(hash_engine)), } } /// Creates a pay to script hash P2SH address from a script /// This address type was introduced with BIP16 and is the popular type to implement multi-sig these days. #[inline] pub fn p2sh(script: &script::Script, network: Network) -> Address { Address { network: network, payload: Payload::ScriptHash(ScriptHash::hash(&script[..])), } } /// Create a witness pay to public key address from a public key /// This is the native segwit address type for an output redeemable with a single signature /// /// Will only return an Error when an uncompressed public key is provided. pub fn p2wpkh(pk: &ecdsa::PublicKey, network: Network) -> Result { if !pk.compressed { return Err(Error::UncompressedPubkey); } let mut hash_engine = WPubkeyHash::engine(); pk.write_into(&mut hash_engine).expect("engines don't error"); Ok(Address { network: network, payload: Payload::WitnessProgram { version: bech32::u5::try_from_u8(0).expect("0<32"), program: WPubkeyHash::from_engine(hash_engine)[..].to_vec(), }, }) } /// Create a pay to script address that embeds a witness pay to public key /// This is a segwit address type that looks familiar (as p2sh) to legacy clients /// /// Will only return an Error when an uncompressed public key is provided. pub fn p2shwpkh(pk: &ecdsa::PublicKey, network: Network) -> Result { if !pk.compressed { return Err(Error::UncompressedPubkey); } let mut hash_engine = WPubkeyHash::engine(); pk.write_into(&mut hash_engine).expect("engines don't error"); let builder = script::Builder::new() .push_int(0) .push_slice(&WPubkeyHash::from_engine(hash_engine)[..]); Ok(Address { network: network, payload: Payload::ScriptHash(ScriptHash::hash(builder.into_script().as_bytes())), }) } /// Create a witness pay to script hash address pub fn p2wsh(script: &script::Script, network: Network) -> Address { Address { network: network, payload: Payload::WitnessProgram { version: bech32::u5::try_from_u8(0).expect("0<32"), program: WScriptHash::hash(&script[..])[..].to_vec(), }, } } /// Create a pay to script address that embeds a witness pay to script hash address /// This is a segwit address type that looks familiar (as p2sh) to legacy clients pub fn p2shwsh(script: &script::Script, network: Network) -> Address { let ws = script::Builder::new() .push_int(0) .push_slice(&WScriptHash::hash(&script[..])[..]) .into_script(); Address { network: network, payload: Payload::ScriptHash(ScriptHash::hash(&ws[..])), } } /// Get the address type of the address. /// None if unknown or non-standard. pub fn address_type(&self) -> Option { match self.payload { Payload::PubkeyHash(_) => Some(AddressType::P2pkh), Payload::ScriptHash(_) => Some(AddressType::P2sh), Payload::WitnessProgram { version: ver, program: ref prog, } => { // BIP-141 p2wpkh or p2wsh addresses. match ver.to_u8() { 0 => match prog.len() { 20 => Some(AddressType::P2wpkh), 32 => Some(AddressType::P2wsh), _ => None, }, _ => None, } } } } /// Check whether or not the address is following Bitcoin /// standardness rules. /// /// Segwit addresses with unassigned witness versions or non-standard /// program sizes are considered non-standard. pub fn is_standard(&self) -> bool { self.address_type().is_some() } /// Get an [Address] from an output script (scriptPubkey). pub fn from_script(script: &script::Script, network: Network) -> Option
{ Some(Address { payload: Payload::from_script(script)?, network: network, }) } /// Generates a script pubkey spending to this address pub fn script_pubkey(&self) -> script::Script { self.payload.script_pubkey() } /// Creates a URI string *bitcoin:address* optimized to be encoded in QR codes. /// /// If the address is bech32, both the schema and the address become uppercase. /// If the address is base58, the schema is lowercase and the address is left mixed case. /// /// Quoting BIP 173 "inside QR codes uppercase SHOULD be used, as those permit the use of /// alphanumeric mode, which is 45% more compact than the normal byte mode." pub fn to_qr_uri(&self) -> String { let schema = match self.payload { Payload::WitnessProgram { .. } => "BITCOIN", _ => "bitcoin", }; format!("{}:{:#}", schema, self) } } // Alternate formatting `{:#}` is used to return uppercase version of bech32 addresses which should // be used in QR codes, see [Address::to_qr_uri] impl fmt::Display for Address { fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result { match self.payload { Payload::PubkeyHash(ref hash) => { let mut prefixed = [0; 21]; prefixed[0] = match self.network { Network::Bitcoin => 0, Network::Testnet | Network::Signet | Network::Regtest => 111, }; prefixed[1..].copy_from_slice(&hash[..]); base58::check_encode_slice_to_fmt(fmt, &prefixed[..]) } Payload::ScriptHash(ref hash) => { let mut prefixed = [0; 21]; prefixed[0] = match self.network { Network::Bitcoin => 5, Network::Testnet | Network::Signet | Network::Regtest => 196, }; prefixed[1..].copy_from_slice(&hash[..]); base58::check_encode_slice_to_fmt(fmt, &prefixed[..]) } Payload::WitnessProgram { version: ver, program: ref prog, } => { let hrp = match self.network { Network::Bitcoin => "bc", Network::Testnet | Network::Signet => "tb", Network::Regtest => "bcrt", }; let bech_ver = if ver.to_u8() > 0 { bech32::Variant::Bech32m } else { bech32::Variant::Bech32 }; let mut upper_writer; let writer = if fmt.alternate() { upper_writer = UpperWriter(fmt); &mut upper_writer as &mut dyn fmt::Write } else { fmt as &mut dyn fmt::Write }; let mut bech32_writer = bech32::Bech32Writer::new(hrp, bech_ver, writer)?; bech32::WriteBase32::write_u5(&mut bech32_writer, ver)?; bech32::ToBase32::write_base32(&prog, &mut bech32_writer) } } } } struct UpperWriter(W); impl fmt::Write for UpperWriter { fn write_str(&mut self, s: &str) -> fmt::Result { for c in s.chars() { self.0.write_char(c.to_ascii_uppercase())?; } Ok(()) } } /// Extract the bech32 prefix. /// Returns the same slice when no prefix is found. fn find_bech32_prefix(bech32: &str) -> &str { // Split at the last occurrence of the separator character '1'. match bech32.rfind('1') { None => bech32, Some(sep) => bech32.split_at(sep).0, } } impl FromStr for Address { type Err = Error; fn from_str(s: &str) -> Result { // try bech32 let bech32_network = match find_bech32_prefix(s) { // note that upper or lowercase is allowed but NOT mixed case "bc" | "BC" => Some(Network::Bitcoin), "tb" | "TB" => Some(Network::Testnet), // this may also be signet "bcrt" | "BCRT" => Some(Network::Regtest), _ => None, }; if let Some(network) = bech32_network { // decode as bech32 let (_, payload, variant) = bech32::decode(s)?; if payload.is_empty() { return Err(Error::EmptyBech32Payload); } // Get the script version and program (converted from 5-bit to 8-bit) let (version, program): (bech32::u5, Vec) = { let (v, p5) = payload.split_at(1); (v[0], bech32::FromBase32::from_base32(p5)?) }; // Generic segwit checks. if version.to_u8() > 16 { return Err(Error::InvalidWitnessVersion(version.to_u8())); } if program.len() < 2 || program.len() > 40 { return Err(Error::InvalidWitnessProgramLength(program.len())); } // Specific segwit v0 check. if version.to_u8() == 0 && (program.len() != 20 && program.len() != 32) { return Err(Error::InvalidSegwitV0ProgramLength(program.len())); } // Bech32 encoding check if (version.to_u8() > 0 && variant != bech32::Variant::Bech32m) || (version.to_u8() == 0 && variant != bech32::Variant::Bech32) { return Err(Error::InvalidWitnessVersion(version.to_u8())) } return Ok(Address { payload: Payload::WitnessProgram { version: version, program: program, }, network: network, }); } // Base58 if s.len() > 50 { return Err(Error::Base58(base58::Error::InvalidLength(s.len() * 11 / 15))); } let data = base58::from_check(s)?; if data.len() != 21 { return Err(Error::Base58(base58::Error::InvalidLength(data.len()))); } let (network, payload) = match data[0] { 0 => ( Network::Bitcoin, Payload::PubkeyHash(PubkeyHash::from_slice(&data[1..]).unwrap()), ), 5 => ( Network::Bitcoin, Payload::ScriptHash(ScriptHash::from_slice(&data[1..]).unwrap()), ), 111 => ( Network::Testnet, Payload::PubkeyHash(PubkeyHash::from_slice(&data[1..]).unwrap()), ), 196 => ( Network::Testnet, Payload::ScriptHash(ScriptHash::from_slice(&data[1..]).unwrap()), ), x => return Err(Error::Base58(base58::Error::InvalidAddressVersion(x))), }; Ok(Address { network: network, payload: payload, }) } } impl fmt::Debug for Address { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "{}", self.to_string()) } } #[cfg(test)] mod tests { use core::str::FromStr; use hashes::hex::{FromHex, ToHex}; use blockdata::script::Script; use network::constants::Network::{Bitcoin, Testnet}; use util::ecdsa::PublicKey; use super::*; macro_rules! hex (($hex:expr) => (Vec::from_hex($hex).unwrap())); macro_rules! hex_key (($hex:expr) => (PublicKey::from_slice(&hex!($hex)).unwrap())); macro_rules! hex_script (($hex:expr) => (Script::from(hex!($hex)))); macro_rules! hex_pubkeyhash (($hex:expr) => (PubkeyHash::from_hex(&$hex).unwrap())); macro_rules! hex_scripthash (($hex:expr) => (ScriptHash::from_hex($hex).unwrap())); fn roundtrips(addr: &Address) { assert_eq!( Address::from_str(&addr.to_string()).unwrap(), *addr, "string round-trip failed for {}", addr, ); assert_eq!( Address::from_script(&addr.script_pubkey(), addr.network).as_ref(), Some(addr), "script round-trip failed for {}", addr, ); //TODO: add serde roundtrip after no-strason PR } #[test] fn test_p2pkh_address_58() { let addr = Address { network: Bitcoin, payload: Payload::PubkeyHash(hex_pubkeyhash!("162c5ea71c0b23f5b9022ef047c4a86470a5b070")), }; assert_eq!( addr.script_pubkey(), hex_script!("76a914162c5ea71c0b23f5b9022ef047c4a86470a5b07088ac") ); assert_eq!(&addr.to_string(), "132F25rTsvBdp9JzLLBHP5mvGY66i1xdiM"); assert_eq!(addr.address_type(), Some(AddressType::P2pkh)); roundtrips(&addr); } #[test] fn test_p2pkh_from_key() { let key = hex_key!("048d5141948c1702e8c95f438815794b87f706a8d4cd2bffad1dc1570971032c9b6042a0431ded2478b5c9cf2d81c124a5e57347a3c63ef0e7716cf54d613ba183"); let addr = Address::p2pkh(&key, Bitcoin); assert_eq!(&addr.to_string(), "1QJVDzdqb1VpbDK7uDeyVXy9mR27CJiyhY"); let key = hex_key!(&"03df154ebfcf29d29cc10d5c2565018bce2d9edbab267c31d2caf44a63056cf99f"); let addr = Address::p2pkh(&key, Testnet); assert_eq!(&addr.to_string(), "mqkhEMH6NCeYjFybv7pvFC22MFeaNT9AQC"); assert_eq!(addr.address_type(), Some(AddressType::P2pkh)); roundtrips(&addr); } #[test] fn test_p2sh_address_58() { let addr = Address { network: Bitcoin, payload: Payload::ScriptHash(hex_scripthash!("162c5ea71c0b23f5b9022ef047c4a86470a5b070")), }; assert_eq!( addr.script_pubkey(), hex_script!("a914162c5ea71c0b23f5b9022ef047c4a86470a5b07087") ); assert_eq!(&addr.to_string(), "33iFwdLuRpW1uK1RTRqsoi8rR4NpDzk66k"); assert_eq!(addr.address_type(), Some(AddressType::P2sh)); roundtrips(&addr); } #[test] fn test_p2sh_parse() { let script = hex_script!("552103a765fc35b3f210b95223846b36ef62a4e53e34e2925270c2c7906b92c9f718eb2103c327511374246759ec8d0b89fa6c6b23b33e11f92c5bc155409d86de0c79180121038cae7406af1f12f4786d820a1466eec7bc5785a1b5e4a387eca6d797753ef6db2103252bfb9dcaab0cd00353f2ac328954d791270203d66c2be8b430f115f451b8a12103e79412d42372c55dd336f2eb6eb639ef9d74a22041ba79382c74da2338fe58ad21035049459a4ebc00e876a9eef02e72a3e70202d3d1f591fc0dd542f93f642021f82102016f682920d9723c61b27f562eb530c926c00106004798b6471e8c52c60ee02057ae"); let addr = Address::p2sh(&script, Testnet); assert_eq!(&addr.to_string(), "2N3zXjbwdTcPsJiy8sUK9FhWJhqQCxA8Jjr"); assert_eq!(addr.address_type(), Some(AddressType::P2sh)); roundtrips(&addr); } #[test] fn test_p2wpkh() { // stolen from Bitcoin transaction: b3c8c2b6cfc335abbcb2c7823a8453f55d64b2b5125a9a61e8737230cdb8ce20 let mut key = hex_key!("033bc8c83c52df5712229a2f72206d90192366c36428cb0c12b6af98324d97bfbc"); let addr = Address::p2wpkh(&key, Bitcoin).unwrap(); assert_eq!(&addr.to_string(), "bc1qvzvkjn4q3nszqxrv3nraga2r822xjty3ykvkuw"); assert_eq!(addr.address_type(), Some(AddressType::P2wpkh)); roundtrips(&addr); // Test uncompressed pubkey key.compressed = false; assert_eq!(Address::p2wpkh(&key, Bitcoin), Err(Error::UncompressedPubkey)); } #[test] fn test_p2wsh() { // stolen from Bitcoin transaction 5df912fda4becb1c29e928bec8d64d93e9ba8efa9b5b405bd683c86fd2c65667 let script = hex_script!("52210375e00eb72e29da82b89367947f29ef34afb75e8654f6ea368e0acdfd92976b7c2103a1b26313f430c4b15bb1fdce663207659d8cac749a0e53d70eff01874496feff2103c96d495bfdd5ba4145e3e046fee45e84a8a48ad05bd8dbb395c011a32cf9f88053ae"); let addr = Address::p2wsh(&script, Bitcoin); assert_eq!( &addr.to_string(), "bc1qwqdg6squsna38e46795at95yu9atm8azzmyvckulcc7kytlcckxswvvzej" ); assert_eq!(addr.address_type(), Some(AddressType::P2wsh)); roundtrips(&addr); } #[test] fn test_p2shwpkh() { // stolen from Bitcoin transaction: ad3fd9c6b52e752ba21425435ff3dd361d6ac271531fc1d2144843a9f550ad01 let mut key = hex_key!("026c468be64d22761c30cd2f12cbc7de255d592d7904b1bab07236897cc4c2e766"); let addr = Address::p2shwpkh(&key, Bitcoin).unwrap(); assert_eq!(&addr.to_string(), "3QBRmWNqqBGme9er7fMkGqtZtp4gjMFxhE"); assert_eq!(addr.address_type(), Some(AddressType::P2sh)); roundtrips(&addr); // Test uncompressed pubkey key.compressed = false; assert_eq!(Address::p2wpkh(&key, Bitcoin), Err(Error::UncompressedPubkey)); } #[test] fn test_p2shwsh() { // stolen from Bitcoin transaction f9ee2be4df05041d0e0a35d7caa3157495ca4f93b233234c9967b6901dacf7a9 let script = hex_script!("522103e5529d8eaa3d559903adb2e881eb06c86ac2574ffa503c45f4e942e2a693b33e2102e5f10fcdcdbab211e0af6a481f5532536ec61a5fdbf7183770cf8680fe729d8152ae"); let addr = Address::p2shwsh(&script, Bitcoin); assert_eq!(&addr.to_string(), "36EqgNnsWW94SreZgBWc1ANC6wpFZwirHr"); assert_eq!(addr.address_type(), Some(AddressType::P2sh)); roundtrips(&addr); } #[test] fn test_non_existent_segwit_version() { let version = 13; // 40-byte program let program = hex!( "654f6ea368e0acdfd92976b7c2103a1b26313f430654f6ea368e0acdfd92976b7c2103a1b26313f4" ); let addr = Address { payload: Payload::WitnessProgram { version: bech32::u5::try_from_u8(version).expect("0<32"), program: program, }, network: Network::Bitcoin, }; roundtrips(&addr); } #[test] fn test_bip173_350_vectors() { // Test vectors valid under both BIP-173 and BIP-350 let valid_vectors = [ ("BC1QW508D6QEJXTDG4Y5R3ZARVARY0C5XW7KV8F3T4", "0014751e76e8199196d454941c45d1b3a323f1433bd6"), ("tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k7", "00201863143c14c5166804bd19203356da136c985678cd4d27a1b8c6329604903262"), ("bc1pw508d6qejxtdg4y5r3zarvary0c5xw7kw508d6qejxtdg4y5r3zarvary0c5xw7kt5nd6y", "5128751e76e8199196d454941c45d1b3a323f1433bd6751e76e8199196d454941c45d1b3a323f1433bd6"), ("BC1SW50QGDZ25J", "6002751e"), ("bc1zw508d6qejxtdg4y5r3zarvaryvaxxpcs", "5210751e76e8199196d454941c45d1b3a323"), ("tb1qqqqqp399et2xygdj5xreqhjjvcmzhxw4aywxecjdzew6hylgvsesrxh6hy", "0020000000c4a5cad46221b2a187905e5266362b99d5e91c6ce24d165dab93e86433"), ("tb1pqqqqp399et2xygdj5xreqhjjvcmzhxw4aywxecjdzew6hylgvsesf3hn0c", "5120000000c4a5cad46221b2a187905e5266362b99d5e91c6ce24d165dab93e86433"), ("bc1p0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vqzk5jj0", "512079be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798") ]; for vector in &valid_vectors { let addr: Address = vector.0.parse().unwrap(); assert_eq!(&addr.script_pubkey().as_bytes().to_hex(), vector.1); roundtrips(&addr); } let invalid_vectors = [ // 1. BIP-350 test vectors // Invalid human-readable part "tc1p0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vq5zuyut", // Invalid checksums (Bech32 instead of Bech32m): "bc1p0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vqh2y7hd", "tb1z0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vqglt7rf", "BC1S0XLXVLHEMJA6C4DQV22UAPCTQUPFHLXM9H8Z3K2E72Q4K9HCZ7VQ54WELL", "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kemeawh", "tb1q0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vq24jc47", // Invalid character in checksum "bc1p38j9r5y49hruaue7wxjce0updqjuyyx0kh56v8s25huc6995vvpql3jow4", // Invalid witness version "BC130XLXVLHEMJA6C4DQV22UAPCTQUPFHLXM9H8Z3K2E72Q4K9HCZ7VQ7ZWS8R", // Invalid program length (1 byte) "bc1pw5dgrnzv", // Invalid program length (41 bytes) "bc1p0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7v8n0nx0muaewav253zgeav", // Invalid program length for witness version 0 (per BIP141) "BC1QR508D6QEJXTDG4Y5R3ZARVARYV98GJ9P", // Mixed case "tb1p0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vq47Zagq", // zero padding of more than 4 bits "bc1p0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7v07qwwzcrf", // Non-zero padding in 8-to-5 conversion "tb1p0xlxvlhemja6c4dqv22uapctqupfhlxm9h8z3k2e72q4k9hcz7vpggkg4j", // Empty data section "bc1gmk9yu", // 2. BIP-173 test vectors // Invalid human-readable part "tc1qw508d6qejxtdg4y5r3zarvary0c5xw7kg3g4ty", // Invalid checksum "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t5", // Invalid witness version "BC13W508D6QEJXTDG4Y5R3ZARVARY0C5XW7KN40WF2", // Invalid program length "bc1rw5uspcuh", // Invalid program length "bc10w508d6qejxtdg4y5r3zarvary0c5xw7kw508d6qejxtdg4y5r3zarvary0c5xw7kw5rljs90", // Invalid program length for witness version 0 (per BIP141) "BC1QR508D6QEJXTDG4Y5R3ZARVARYV98GJ9P", // Mixed case "tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sL5k7", // zero padding of more than 4 bits "bc1zw508d6qejxtdg4y5r3zarvaryvqyzf3du", // Non-zero padding in 8-to-5 conversion "tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3pjxtptv", // Final test for empty data section is the same as above in BIP-350 // 3. BIP-173 valid test vectors obsolete by BIP-350 "bc1pw508d6qejxtdg4y5r3zarvary0c5xw7kw508d6qejxtdg4y5r3zarvary0c5xw7k7grplx", "BC1SW50QA3JX3S", "bc1zw508d6qejxtdg4y5r3zarvaryvg6kdaj", ]; for vector in &invalid_vectors { assert!(vector.parse::
().is_err()); } } #[test] #[cfg(feature = "serde")] fn test_json_serialize() { use serde_json; let addr = Address::from_str("132F25rTsvBdp9JzLLBHP5mvGY66i1xdiM").unwrap(); let json = serde_json::to_value(&addr).unwrap(); assert_eq!( json, serde_json::Value::String("132F25rTsvBdp9JzLLBHP5mvGY66i1xdiM".to_owned()) ); let into: Address = serde_json::from_value(json).unwrap(); assert_eq!(addr.to_string(), into.to_string()); assert_eq!( into.script_pubkey(), hex_script!("76a914162c5ea71c0b23f5b9022ef047c4a86470a5b07088ac") ); let addr = Address::from_str("33iFwdLuRpW1uK1RTRqsoi8rR4NpDzk66k").unwrap(); let json = serde_json::to_value(&addr).unwrap(); assert_eq!( json, serde_json::Value::String("33iFwdLuRpW1uK1RTRqsoi8rR4NpDzk66k".to_owned()) ); let into: Address = serde_json::from_value(json).unwrap(); assert_eq!(addr.to_string(), into.to_string()); assert_eq!( into.script_pubkey(), hex_script!("a914162c5ea71c0b23f5b9022ef047c4a86470a5b07087") ); let addr = Address::from_str("tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k7") .unwrap(); let json = serde_json::to_value(&addr).unwrap(); assert_eq!( json, serde_json::Value::String( "tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k7".to_owned() ) ); let into: Address = serde_json::from_value(json).unwrap(); assert_eq!(addr.to_string(), into.to_string()); assert_eq!( into.script_pubkey(), hex_script!("00201863143c14c5166804bd19203356da136c985678cd4d27a1b8c6329604903262") ); let addr = Address::from_str("bcrt1q2nfxmhd4n3c8834pj72xagvyr9gl57n5r94fsl").unwrap(); let json = serde_json::to_value(&addr).unwrap(); assert_eq!( json, serde_json::Value::String("bcrt1q2nfxmhd4n3c8834pj72xagvyr9gl57n5r94fsl".to_owned()) ); let into: Address = serde_json::from_value(json).unwrap(); assert_eq!(addr.to_string(), into.to_string()); assert_eq!( into.script_pubkey(), hex_script!("001454d26dddb59c7073c6a197946ea1841951fa7a74") ); } #[test] fn test_qr_string() { for el in ["132F25rTsvBdp9JzLLBHP5mvGY66i1xdiM", "33iFwdLuRpW1uK1RTRqsoi8rR4NpDzk66k"].iter() { let addr = Address::from_str(el).unwrap(); assert_eq!(addr.to_qr_uri(), format!("bitcoin:{}", el)); } for el in ["bcrt1q2nfxmhd4n3c8834pj72xagvyr9gl57n5r94fsl", "bc1qwqdg6squsna38e46795at95yu9atm8azzmyvckulcc7kytlcckxswvvzej"].iter() { let addr = Address::from_str(el).unwrap(); assert_eq!(addr.to_qr_uri(), format!("BITCOIN:{}", el.to_ascii_uppercase()) ); } } }