2015-10-14 20:29:19 +00:00
|
|
|
// Rust Bitcoin Library
|
|
|
|
// Written in 2014 by
|
|
|
|
// Andrew Poelstra <apoelstra@wpsoftware.net>
|
|
|
|
// 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 <http://creativecommons.org/publicdomain/zero/1.0/>.
|
|
|
|
//
|
|
|
|
|
2018-08-08 21:38:50 +00:00
|
|
|
//! Addresses
|
|
|
|
//!
|
2015-10-15 00:25:43 +00:00
|
|
|
//! Support for ordinary base58 Bitcoin addresses and private keys
|
2015-10-14 20:29:19 +00:00
|
|
|
//!
|
2018-09-29 21:00:37 +00:00
|
|
|
//! # Example: creating a new address from a randomly-generated key pair
|
|
|
|
//!
|
|
|
|
//! ```rust
|
|
|
|
//! extern crate secp256k1;
|
|
|
|
//! extern crate bitcoin;
|
2019-07-11 17:06:42 +00:00
|
|
|
//!
|
2018-09-29 21:00:37 +00:00
|
|
|
//! use bitcoin::network::constants::Network;
|
|
|
|
//! use bitcoin::util::address::Address;
|
2018-11-16 04:21:41 +00:00
|
|
|
//! use bitcoin::util::key;
|
2018-09-29 21:00:37 +00:00
|
|
|
//! use secp256k1::Secp256k1;
|
2019-06-07 13:04:19 +00:00
|
|
|
//! use secp256k1::rand::thread_rng;
|
2019-07-11 17:06:42 +00:00
|
|
|
//!
|
2018-09-29 21:00:37 +00:00
|
|
|
//! fn main() {
|
|
|
|
//! // Generate random key pair
|
|
|
|
//! let s = Secp256k1::new();
|
2018-11-16 04:21:41 +00:00
|
|
|
//! let public_key = key::PublicKey {
|
|
|
|
//! compressed: true,
|
|
|
|
//! key: s.generate_keypair(&mut thread_rng()).1,
|
|
|
|
//! };
|
2019-07-11 17:06:42 +00:00
|
|
|
//!
|
2019-01-21 16:40:04 +00:00
|
|
|
//! // Generate pay-to-pubkey-hash address
|
|
|
|
//! let address = Address::p2pkh(&public_key, Network::Bitcoin);
|
2018-09-29 21:00:37 +00:00
|
|
|
//! }
|
|
|
|
//! ```
|
2015-10-14 20:29:19 +00:00
|
|
|
|
2018-08-20 19:40:00 +00:00
|
|
|
use std::fmt::{self, Display, Formatter};
|
2018-03-09 17:53:20 +00:00
|
|
|
use std::str::FromStr;
|
|
|
|
|
2018-06-21 18:45:58 +00:00
|
|
|
use bitcoin_bech32::{self, WitnessProgram, u5};
|
2019-01-16 20:45:31 +00:00
|
|
|
use bitcoin_hashes::{hash160, Hash};
|
2015-10-14 20:29:19 +00:00
|
|
|
|
2018-08-30 19:01:54 +00:00
|
|
|
#[cfg(feature = "serde")]
|
|
|
|
use serde;
|
|
|
|
|
2015-10-14 20:29:19 +00:00
|
|
|
use blockdata::opcodes;
|
2018-08-30 19:01:54 +00:00
|
|
|
use blockdata::script;
|
2015-10-14 20:29:19 +00:00
|
|
|
use network::constants::Network;
|
Move relevant names into consensus::encode
- Move network::encodable::* to consensus::encode::*
- Rename Consensus{En,De}codable to {En,De}codable (now under
consensus::encode)
- Move network::serialize::Error to consensus::encode::Error
- Remove Raw{En,De}coder, implement {En,De}coder for T: {Write,Read}
instead
- Move network::serialize::Simple{En,De}coder to
consensus::encode::{En,De}coder
- Rename util::Error::Serialize to util::Error::Encode
- Modify comments to refer to new names
- Modify files to refer to new names
- Expose {En,De}cod{able,er}, {de,}serialize, Params
- Do not return Result for serialize{,_hex} as serializing to a Vec
should never fail
2018-09-20 10:15:45 +00:00
|
|
|
use consensus::encode;
|
2018-03-09 17:53:20 +00:00
|
|
|
use util::base58;
|
2018-11-16 04:21:41 +00:00
|
|
|
use util::key;
|
2015-10-14 20:29:19 +00:00
|
|
|
|
|
|
|
/// The method used to produce an address
|
2018-08-20 09:10:21 +00:00
|
|
|
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
2018-03-09 20:27:13 +00:00
|
|
|
pub enum Payload {
|
|
|
|
/// pay-to-pkhash address
|
2019-01-16 20:45:31 +00:00
|
|
|
PubkeyHash(hash160::Hash),
|
2018-03-09 20:27:13 +00:00
|
|
|
/// P2SH address
|
2019-01-16 20:45:31 +00:00
|
|
|
ScriptHash(hash160::Hash),
|
2018-03-09 20:27:13 +00:00
|
|
|
/// Segwit address
|
|
|
|
WitnessProgram(WitnessProgram),
|
2015-10-14 20:29:19 +00:00
|
|
|
}
|
|
|
|
|
2018-08-20 09:10:21 +00:00
|
|
|
#[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
2015-10-14 20:29:19 +00:00
|
|
|
/// A Bitcoin address
|
|
|
|
pub struct Address {
|
|
|
|
/// The type of the address
|
2018-03-09 20:27:13 +00:00
|
|
|
pub payload: Payload,
|
2015-10-14 20:29:19 +00:00
|
|
|
/// The network on which this address is usable
|
2018-11-16 04:21:41 +00:00
|
|
|
pub network: Network,
|
2015-10-14 20:29:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
impl Address {
|
2018-03-14 03:53:03 +00:00
|
|
|
/// Creates a pay to (compressed) public key hash address from a public key
|
|
|
|
/// This is the preferred non-witness type address
|
2015-10-14 20:29:19 +00:00
|
|
|
#[inline]
|
2018-11-16 04:21:41 +00:00
|
|
|
pub fn p2pkh(pk: &key::PublicKey, network: Network) -> Address {
|
|
|
|
let mut hash_engine = hash160::Hash::engine();
|
|
|
|
pk.write_into(&mut hash_engine);
|
2015-10-14 20:29:19 +00:00
|
|
|
|
2015-10-15 03:21:09 +00:00
|
|
|
Address {
|
|
|
|
network: network,
|
2018-11-16 04:21:41 +00:00
|
|
|
payload: Payload::PubkeyHash(hash160::Hash::from_engine(hash_engine))
|
2018-03-14 03:53:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Creates a pay to script hash P2SH address from a script
|
2019-02-04 06:30:41 +00:00
|
|
|
/// This address type was introduced with BIP16 and is the popular type to implement multi-sig these days.
|
2018-03-14 03:53:03 +00:00
|
|
|
#[inline]
|
|
|
|
pub fn p2sh(script: &script::Script, network: Network) -> Address {
|
|
|
|
Address {
|
|
|
|
network: network,
|
2019-01-16 20:45:31 +00:00
|
|
|
payload: Payload::ScriptHash(hash160::Hash::hash(&script[..]))
|
2018-03-14 03:53:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Create a witness pay to public key address from a public key
|
2019-01-23 18:30:32 +00:00
|
|
|
/// This is the native segwit address type for an output redeemable with a single signature
|
2018-11-16 04:21:41 +00:00
|
|
|
pub fn p2wpkh (pk: &key::PublicKey, network: Network) -> Address {
|
|
|
|
let mut hash_engine = hash160::Hash::engine();
|
|
|
|
pk.write_into(&mut hash_engine);
|
|
|
|
|
2018-03-14 03:53:03 +00:00
|
|
|
Address {
|
|
|
|
network: network,
|
|
|
|
payload: Payload::WitnessProgram(
|
|
|
|
// unwrap is safe as witness program is known to be correct as above
|
2018-06-21 18:45:58 +00:00
|
|
|
WitnessProgram::new(u5::try_from_u8(0).expect("0<32"),
|
2018-11-16 04:21:41 +00:00
|
|
|
hash160::Hash::from_engine(hash_engine)[..].to_vec(),
|
2018-03-14 03:53:03 +00:00
|
|
|
Address::bech_network(network)).unwrap())
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// 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
|
2018-11-16 04:21:41 +00:00
|
|
|
pub fn p2shwpkh (pk: &key::PublicKey, network: Network) -> Address {
|
|
|
|
let mut hash_engine = hash160::Hash::engine();
|
|
|
|
pk.write_into(&mut hash_engine);
|
|
|
|
|
2018-03-14 03:53:03 +00:00
|
|
|
let builder = script::Builder::new()
|
|
|
|
.push_int(0)
|
2018-11-16 04:21:41 +00:00
|
|
|
.push_slice(&hash160::Hash::from_engine(hash_engine)[..]);
|
|
|
|
|
2018-03-14 03:53:03 +00:00
|
|
|
Address {
|
|
|
|
network: network,
|
|
|
|
payload: Payload::ScriptHash(
|
2019-01-16 20:45:31 +00:00
|
|
|
hash160::Hash::hash(builder.into_script().as_bytes())
|
2018-03-14 03:53:03 +00:00
|
|
|
)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Create a witness pay to script hash address
|
|
|
|
pub fn p2wsh (script: &script::Script, network: Network) -> Address {
|
2019-01-16 20:45:31 +00:00
|
|
|
use bitcoin_hashes::sha256;
|
2018-03-14 03:53:03 +00:00
|
|
|
|
|
|
|
Address {
|
|
|
|
network: network,
|
|
|
|
payload: Payload::WitnessProgram(
|
|
|
|
// unwrap is safe as witness program is known to be correct as above
|
2018-06-21 18:45:58 +00:00
|
|
|
WitnessProgram::new(
|
|
|
|
u5::try_from_u8(0).expect("0<32"),
|
2019-01-16 20:45:31 +00:00
|
|
|
sha256::Hash::hash(&script[..])[..].to_vec(),
|
2018-06-21 18:45:58 +00:00
|
|
|
Address::bech_network(network)
|
|
|
|
).unwrap()
|
2018-11-16 04:21:41 +00:00
|
|
|
),
|
2018-03-14 03:53:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// 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 {
|
2019-01-16 20:45:31 +00:00
|
|
|
use bitcoin_hashes::sha256;
|
2018-03-14 03:53:03 +00:00
|
|
|
|
2019-01-16 20:45:31 +00:00
|
|
|
let ws = script::Builder::new().push_int(0)
|
|
|
|
.push_slice(&sha256::Hash::hash(&script[..])[..])
|
|
|
|
.into_script();
|
2018-03-14 03:53:03 +00:00
|
|
|
|
|
|
|
Address {
|
|
|
|
network: network,
|
2019-01-16 20:45:31 +00:00
|
|
|
payload: Payload::ScriptHash(hash160::Hash::hash(&ws[..]))
|
2015-10-15 03:21:09 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-10-14 20:29:19 +00:00
|
|
|
#[inline]
|
2018-03-14 03:53:03 +00:00
|
|
|
/// convert Network to bech32 network (this should go away soon)
|
|
|
|
fn bech_network (network: Network) -> bitcoin_bech32::constants::Network {
|
|
|
|
match network {
|
|
|
|
Network::Bitcoin => bitcoin_bech32::constants::Network::Bitcoin,
|
2018-07-26 00:51:37 +00:00
|
|
|
Network::Testnet => bitcoin_bech32::constants::Network::Testnet,
|
|
|
|
Network::Regtest => bitcoin_bech32::constants::Network::Regtest,
|
2018-03-14 03:53:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Generates a script pubkey spending to this address
|
2015-10-14 20:29:19 +00:00
|
|
|
pub fn script_pubkey(&self) -> script::Script {
|
2018-03-09 20:27:13 +00:00
|
|
|
match self.payload {
|
|
|
|
Payload::PubkeyHash(ref hash) => {
|
2015-11-04 17:04:54 +00:00
|
|
|
script::Builder::new()
|
2018-11-11 22:52:52 +00:00
|
|
|
.push_opcode(opcodes::all::OP_DUP)
|
|
|
|
.push_opcode(opcodes::all::OP_HASH160)
|
2018-03-09 20:27:13 +00:00
|
|
|
.push_slice(&hash[..])
|
2018-11-11 22:52:52 +00:00
|
|
|
.push_opcode(opcodes::all::OP_EQUALVERIFY)
|
|
|
|
.push_opcode(opcodes::all::OP_CHECKSIG)
|
2018-03-09 20:27:13 +00:00
|
|
|
},
|
|
|
|
Payload::ScriptHash(ref hash) => {
|
2015-11-04 17:04:54 +00:00
|
|
|
script::Builder::new()
|
2018-11-11 22:52:52 +00:00
|
|
|
.push_opcode(opcodes::all::OP_HASH160)
|
2018-03-09 20:27:13 +00:00
|
|
|
.push_slice(&hash[..])
|
2018-11-11 22:52:52 +00:00
|
|
|
.push_opcode(opcodes::all::OP_EQUAL)
|
2018-03-09 20:27:13 +00:00
|
|
|
},
|
|
|
|
Payload::WitnessProgram(ref witprog) => {
|
|
|
|
script::Builder::new()
|
2018-06-21 18:45:58 +00:00
|
|
|
.push_int(witprog.version().to_u8() as i64)
|
2018-03-09 20:27:13 +00:00
|
|
|
.push_slice(witprog.program())
|
2015-10-14 20:29:19 +00:00
|
|
|
}
|
2015-11-04 17:04:54 +00:00
|
|
|
}.into_script()
|
2015-10-14 20:29:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-08-20 19:40:00 +00:00
|
|
|
impl Display for Address {
|
|
|
|
fn fmt(&self, fmt: &mut Formatter) -> fmt::Result {
|
2018-03-09 20:27:13 +00:00
|
|
|
match self.payload {
|
|
|
|
Payload::PubkeyHash(ref hash) => {
|
|
|
|
let mut prefixed = [0; 21];
|
|
|
|
prefixed[0] = match self.network {
|
|
|
|
Network::Bitcoin => 0,
|
2018-05-17 13:08:02 +00:00
|
|
|
Network::Testnet | Network::Regtest => 111,
|
2018-03-09 20:27:13 +00:00
|
|
|
};
|
|
|
|
prefixed[1..].copy_from_slice(&hash[..]);
|
2018-08-20 19:40:00 +00:00
|
|
|
base58::check_encode_slice_to_fmt(fmt, &prefixed[..])
|
2018-03-14 03:53:03 +00:00
|
|
|
},
|
2018-03-09 20:27:13 +00:00
|
|
|
Payload::ScriptHash(ref hash) => {
|
|
|
|
let mut prefixed = [0; 21];
|
|
|
|
prefixed[0] = match self.network {
|
|
|
|
Network::Bitcoin => 5,
|
2018-05-17 13:08:02 +00:00
|
|
|
Network::Testnet | Network::Regtest => 196,
|
2018-03-09 20:27:13 +00:00
|
|
|
};
|
|
|
|
prefixed[1..].copy_from_slice(&hash[..]);
|
2018-08-20 19:40:00 +00:00
|
|
|
base58::check_encode_slice_to_fmt(fmt, &prefixed[..])
|
2018-03-14 03:53:03 +00:00
|
|
|
},
|
2018-03-09 20:27:13 +00:00
|
|
|
Payload::WitnessProgram(ref witprog) => {
|
2018-08-20 19:40:00 +00:00
|
|
|
fmt.write_str(&witprog.to_address())
|
2018-03-09 20:27:13 +00:00
|
|
|
},
|
|
|
|
}
|
2015-10-14 20:29:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-03-09 17:53:20 +00:00
|
|
|
impl FromStr for Address {
|
Move relevant names into consensus::encode
- Move network::encodable::* to consensus::encode::*
- Rename Consensus{En,De}codable to {En,De}codable (now under
consensus::encode)
- Move network::serialize::Error to consensus::encode::Error
- Remove Raw{En,De}coder, implement {En,De}coder for T: {Write,Read}
instead
- Move network::serialize::Simple{En,De}coder to
consensus::encode::{En,De}coder
- Rename util::Error::Serialize to util::Error::Encode
- Modify comments to refer to new names
- Modify files to refer to new names
- Expose {En,De}cod{able,er}, {de,}serialize, Params
- Do not return Result for serialize{,_hex} as serializing to a Vec
should never fail
2018-09-20 10:15:45 +00:00
|
|
|
type Err = encode::Error;
|
2018-03-09 20:27:13 +00:00
|
|
|
|
Move relevant names into consensus::encode
- Move network::encodable::* to consensus::encode::*
- Rename Consensus{En,De}codable to {En,De}codable (now under
consensus::encode)
- Move network::serialize::Error to consensus::encode::Error
- Remove Raw{En,De}coder, implement {En,De}coder for T: {Write,Read}
instead
- Move network::serialize::Simple{En,De}coder to
consensus::encode::{En,De}coder
- Rename util::Error::Serialize to util::Error::Encode
- Modify comments to refer to new names
- Modify files to refer to new names
- Expose {En,De}cod{able,er}, {de,}serialize, Params
- Do not return Result for serialize{,_hex} as serializing to a Vec
should never fail
2018-09-20 10:15:45 +00:00
|
|
|
fn from_str(s: &str) -> Result<Address, encode::Error> {
|
2018-03-09 20:27:13 +00:00
|
|
|
// bech32 (note that upper or lowercase is allowed but NOT mixed case)
|
2018-08-20 22:11:14 +00:00
|
|
|
if s.starts_with("bc1") || s.starts_with("BC1") ||
|
|
|
|
s.starts_with("tb1") || s.starts_with("TB1") ||
|
|
|
|
s.starts_with("bcrt1") || s.starts_with("BCRT1")
|
2018-07-26 07:06:35 +00:00
|
|
|
{
|
|
|
|
let witprog = WitnessProgram::from_address(s)?;
|
2018-03-09 20:27:13 +00:00
|
|
|
let network = match witprog.network() {
|
|
|
|
bitcoin_bech32::constants::Network::Bitcoin => Network::Bitcoin,
|
|
|
|
bitcoin_bech32::constants::Network::Testnet => Network::Testnet,
|
2018-07-26 00:51:37 +00:00
|
|
|
bitcoin_bech32::constants::Network::Regtest => Network::Regtest,
|
2018-03-09 20:27:13 +00:00
|
|
|
_ => panic!("unknown network")
|
|
|
|
};
|
2018-06-21 18:45:58 +00:00
|
|
|
if witprog.version().to_u8() != 0 {
|
Move relevant names into consensus::encode
- Move network::encodable::* to consensus::encode::*
- Rename Consensus{En,De}codable to {En,De}codable (now under
consensus::encode)
- Move network::serialize::Error to consensus::encode::Error
- Remove Raw{En,De}coder, implement {En,De}coder for T: {Write,Read}
instead
- Move network::serialize::Simple{En,De}coder to
consensus::encode::{En,De}coder
- Rename util::Error::Serialize to util::Error::Encode
- Modify comments to refer to new names
- Modify files to refer to new names
- Expose {En,De}cod{able,er}, {de,}serialize, Params
- Do not return Result for serialize{,_hex} as serializing to a Vec
should never fail
2018-09-20 10:15:45 +00:00
|
|
|
return Err(encode::Error::UnsupportedWitnessVersion(witprog.version().to_u8()));
|
2018-03-14 03:53:03 +00:00
|
|
|
}
|
2018-03-09 20:27:13 +00:00
|
|
|
return Ok(Address {
|
|
|
|
network: network,
|
2018-11-16 04:21:41 +00:00
|
|
|
payload: Payload::WitnessProgram(witprog),
|
2018-03-09 20:27:13 +00:00
|
|
|
});
|
|
|
|
}
|
2018-03-09 17:53:20 +00:00
|
|
|
|
2018-05-14 15:07:30 +00:00
|
|
|
if s.len() > 50 {
|
Move relevant names into consensus::encode
- Move network::encodable::* to consensus::encode::*
- Rename Consensus{En,De}codable to {En,De}codable (now under
consensus::encode)
- Move network::serialize::Error to consensus::encode::Error
- Remove Raw{En,De}coder, implement {En,De}coder for T: {Write,Read}
instead
- Move network::serialize::Simple{En,De}coder to
consensus::encode::{En,De}coder
- Rename util::Error::Serialize to util::Error::Encode
- Modify comments to refer to new names
- Modify files to refer to new names
- Expose {En,De}cod{able,er}, {de,}serialize, Params
- Do not return Result for serialize{,_hex} as serializing to a Vec
should never fail
2018-09-20 10:15:45 +00:00
|
|
|
return Err(encode::Error::Base58(base58::Error::InvalidLength(s.len() * 11 / 15)));
|
2018-05-14 15:07:30 +00:00
|
|
|
}
|
|
|
|
|
2018-03-09 20:27:13 +00:00
|
|
|
// Base 58
|
2018-08-12 16:47:31 +00:00
|
|
|
let data = base58::from_check(s)?;
|
2018-03-09 17:53:20 +00:00
|
|
|
|
2015-10-14 20:29:19 +00:00
|
|
|
if data.len() != 21 {
|
Move relevant names into consensus::encode
- Move network::encodable::* to consensus::encode::*
- Rename Consensus{En,De}codable to {En,De}codable (now under
consensus::encode)
- Move network::serialize::Error to consensus::encode::Error
- Remove Raw{En,De}coder, implement {En,De}coder for T: {Write,Read}
instead
- Move network::serialize::Simple{En,De}coder to
consensus::encode::{En,De}coder
- Rename util::Error::Serialize to util::Error::Encode
- Modify comments to refer to new names
- Modify files to refer to new names
- Expose {En,De}cod{able,er}, {de,}serialize, Params
- Do not return Result for serialize{,_hex} as serializing to a Vec
should never fail
2018-09-20 10:15:45 +00:00
|
|
|
return Err(encode::Error::Base58(base58::Error::InvalidLength(data.len())));
|
2015-10-14 20:29:19 +00:00
|
|
|
}
|
|
|
|
|
2018-03-09 20:27:13 +00:00
|
|
|
let (network, payload) = match data[0] {
|
|
|
|
0 => (
|
|
|
|
Network::Bitcoin,
|
2019-01-16 20:45:31 +00:00
|
|
|
Payload::PubkeyHash(hash160::Hash::from_slice(&data[1..]).unwrap())
|
2018-03-09 20:27:13 +00:00
|
|
|
),
|
|
|
|
5 => (
|
|
|
|
Network::Bitcoin,
|
2019-01-16 20:45:31 +00:00
|
|
|
Payload::ScriptHash(hash160::Hash::from_slice(&data[1..]).unwrap())
|
2018-03-09 20:27:13 +00:00
|
|
|
),
|
|
|
|
111 => (
|
|
|
|
Network::Testnet,
|
2019-01-16 20:45:31 +00:00
|
|
|
Payload::PubkeyHash(hash160::Hash::from_slice(&data[1..]).unwrap())
|
2018-03-09 20:27:13 +00:00
|
|
|
),
|
|
|
|
196 => (
|
|
|
|
Network::Testnet,
|
2019-01-16 20:45:31 +00:00
|
|
|
Payload::ScriptHash(hash160::Hash::from_slice(&data[1..]).unwrap())
|
2018-03-09 20:27:13 +00:00
|
|
|
),
|
Move relevant names into consensus::encode
- Move network::encodable::* to consensus::encode::*
- Rename Consensus{En,De}codable to {En,De}codable (now under
consensus::encode)
- Move network::serialize::Error to consensus::encode::Error
- Remove Raw{En,De}coder, implement {En,De}coder for T: {Write,Read}
instead
- Move network::serialize::Simple{En,De}coder to
consensus::encode::{En,De}coder
- Rename util::Error::Serialize to util::Error::Encode
- Modify comments to refer to new names
- Modify files to refer to new names
- Expose {En,De}cod{able,er}, {de,}serialize, Params
- Do not return Result for serialize{,_hex} as serializing to a Vec
should never fail
2018-09-20 10:15:45 +00:00
|
|
|
x => return Err(encode::Error::Base58(base58::Error::InvalidVersion(vec![x])))
|
2015-10-14 20:29:19 +00:00
|
|
|
};
|
|
|
|
|
2018-03-21 18:49:46 +00:00
|
|
|
Ok(Address {
|
|
|
|
network: network,
|
|
|
|
payload: payload,
|
|
|
|
})
|
2015-10-14 20:29:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl ::std::fmt::Debug for Address {
|
|
|
|
fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
|
2018-03-09 17:53:20 +00:00
|
|
|
write!(f, "{}", self.to_string())
|
2015-10-14 20:29:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-08-30 19:01:54 +00:00
|
|
|
#[cfg(feature = "serde")]
|
|
|
|
impl<'de> serde::Deserialize<'de> for Address {
|
|
|
|
#[inline]
|
|
|
|
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
|
|
|
|
where
|
|
|
|
D: serde::Deserializer<'de>,
|
|
|
|
{
|
|
|
|
use std::fmt::{self, Formatter};
|
|
|
|
|
|
|
|
struct Visitor;
|
|
|
|
impl<'de> serde::de::Visitor<'de> for Visitor {
|
|
|
|
type Value = Address;
|
|
|
|
|
|
|
|
fn expecting(&self, formatter: &mut Formatter) -> fmt::Result {
|
|
|
|
formatter.write_str("a Bitcoin address")
|
|
|
|
}
|
|
|
|
|
|
|
|
fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
|
|
|
|
where
|
|
|
|
E: serde::de::Error,
|
|
|
|
{
|
|
|
|
Address::from_str(v).map_err(E::custom)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
|
|
|
|
where
|
|
|
|
E: serde::de::Error,
|
|
|
|
{
|
|
|
|
self.visit_str(v)
|
|
|
|
}
|
|
|
|
|
|
|
|
fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
|
|
|
|
where
|
|
|
|
E: serde::de::Error,
|
|
|
|
{
|
|
|
|
self.visit_str(&v)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
deserializer.deserialize_str(Visitor)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[cfg(feature = "serde")]
|
|
|
|
impl serde::Serialize for Address {
|
|
|
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
|
|
|
where
|
|
|
|
S: serde::Serializer,
|
|
|
|
{
|
|
|
|
serializer.serialize_str(&self.to_string())
|
|
|
|
}
|
|
|
|
}
|
2015-10-15 00:25:43 +00:00
|
|
|
|
2015-10-14 20:29:19 +00:00
|
|
|
#[cfg(test)]
|
|
|
|
mod tests {
|
2018-03-09 17:53:20 +00:00
|
|
|
use std::str::FromStr;
|
|
|
|
use std::string::ToString;
|
|
|
|
|
2019-01-16 20:45:31 +00:00
|
|
|
use bitcoin_hashes::{hash160, Hash};
|
2018-07-24 18:43:03 +00:00
|
|
|
use hex::decode as hex_decode;
|
2015-10-14 20:29:19 +00:00
|
|
|
|
|
|
|
use blockdata::script::Script;
|
2018-07-26 00:51:37 +00:00
|
|
|
use network::constants::Network::{Bitcoin, Testnet, Regtest};
|
2018-11-16 04:21:41 +00:00
|
|
|
use util::key::PublicKey;
|
|
|
|
|
2015-10-14 20:29:19 +00:00
|
|
|
use super::*;
|
|
|
|
|
2018-07-24 18:43:03 +00:00
|
|
|
macro_rules! hex (($hex:expr) => (hex_decode($hex).unwrap()));
|
2019-01-15 17:05:41 +00:00
|
|
|
macro_rules! hex_key (($hex:expr) => (PublicKey::from_slice(&hex!($hex)).unwrap()));
|
2015-10-14 20:29:19 +00:00
|
|
|
macro_rules! hex_script (($hex:expr) => (Script::from(hex!($hex))));
|
2019-01-16 20:45:31 +00:00
|
|
|
macro_rules! hex_hash160 (($hex:expr) => (hash160::Hash::from_slice(&hex!($hex)).unwrap()));
|
2015-10-14 20:29:19 +00:00
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_p2pkh_address_58() {
|
|
|
|
let addr = Address {
|
|
|
|
network: Bitcoin,
|
2018-03-09 20:27:13 +00:00
|
|
|
payload: Payload::PubkeyHash(
|
2019-01-16 20:45:31 +00:00
|
|
|
hex_hash160!("162c5ea71c0b23f5b9022ef047c4a86470a5b070")
|
2018-03-14 03:53:03 +00:00
|
|
|
)
|
2015-10-14 20:29:19 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
assert_eq!(addr.script_pubkey(), hex_script!("76a914162c5ea71c0b23f5b9022ef047c4a86470a5b07088ac"));
|
2018-03-09 17:53:20 +00:00
|
|
|
assert_eq!(&addr.to_string(), "132F25rTsvBdp9JzLLBHP5mvGY66i1xdiM");
|
2018-03-09 20:27:13 +00:00
|
|
|
assert_eq!(Address::from_str("132F25rTsvBdp9JzLLBHP5mvGY66i1xdiM").unwrap(), addr);
|
2015-10-14 20:29:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_p2pkh_from_key() {
|
2019-01-15 17:05:41 +00:00
|
|
|
let key = hex_key!("048d5141948c1702e8c95f438815794b87f706a8d4cd2bffad1dc1570971032c9b6042a0431ded2478b5c9cf2d81c124a5e57347a3c63ef0e7716cf54d613ba183");
|
2018-11-16 04:21:41 +00:00
|
|
|
let addr = Address::p2pkh(&key, Bitcoin);
|
2018-03-09 17:53:20 +00:00
|
|
|
assert_eq!(&addr.to_string(), "1QJVDzdqb1VpbDK7uDeyVXy9mR27CJiyhY");
|
2015-10-14 20:29:19 +00:00
|
|
|
|
2019-01-15 17:05:41 +00:00
|
|
|
let key = hex_key!(&"03df154ebfcf29d29cc10d5c2565018bce2d9edbab267c31d2caf44a63056cf99f");
|
2018-03-14 03:53:03 +00:00
|
|
|
let addr = Address::p2pkh(&key, Testnet);
|
2018-03-09 17:53:20 +00:00
|
|
|
assert_eq!(&addr.to_string(), "mqkhEMH6NCeYjFybv7pvFC22MFeaNT9AQC");
|
2015-10-14 20:29:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_p2sh_address_58() {
|
|
|
|
let addr = Address {
|
|
|
|
network: Bitcoin,
|
2018-03-09 20:27:13 +00:00
|
|
|
payload: Payload::ScriptHash(
|
2019-01-16 20:45:31 +00:00
|
|
|
hex_hash160!("162c5ea71c0b23f5b9022ef047c4a86470a5b070")
|
2018-03-14 03:53:03 +00:00
|
|
|
)
|
2015-10-14 20:29:19 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
assert_eq!(addr.script_pubkey(), hex_script!("a914162c5ea71c0b23f5b9022ef047c4a86470a5b07087"));
|
2018-03-09 17:53:20 +00:00
|
|
|
assert_eq!(&addr.to_string(), "33iFwdLuRpW1uK1RTRqsoi8rR4NpDzk66k");
|
2018-03-09 20:27:13 +00:00
|
|
|
assert_eq!(Address::from_str("33iFwdLuRpW1uK1RTRqsoi8rR4NpDzk66k").unwrap(), addr);
|
2015-10-14 20:29:19 +00:00
|
|
|
}
|
2015-10-15 00:25:43 +00:00
|
|
|
|
2015-10-15 03:21:09 +00:00
|
|
|
#[test]
|
|
|
|
fn test_p2sh_parse() {
|
|
|
|
let script = hex_script!("552103a765fc35b3f210b95223846b36ef62a4e53e34e2925270c2c7906b92c9f718eb2103c327511374246759ec8d0b89fa6c6b23b33e11f92c5bc155409d86de0c79180121038cae7406af1f12f4786d820a1466eec7bc5785a1b5e4a387eca6d797753ef6db2103252bfb9dcaab0cd00353f2ac328954d791270203d66c2be8b430f115f451b8a12103e79412d42372c55dd336f2eb6eb639ef9d74a22041ba79382c74da2338fe58ad21035049459a4ebc00e876a9eef02e72a3e70202d3d1f591fc0dd542f93f642021f82102016f682920d9723c61b27f562eb530c926c00106004798b6471e8c52c60ee02057ae");
|
2018-03-14 03:53:03 +00:00
|
|
|
let addr = Address::p2sh(&script, Testnet);
|
2015-10-15 03:21:09 +00:00
|
|
|
|
2018-03-09 17:53:20 +00:00
|
|
|
assert_eq!(&addr.to_string(), "2N3zXjbwdTcPsJiy8sUK9FhWJhqQCxA8Jjr");
|
2018-03-09 20:27:13 +00:00
|
|
|
assert_eq!(Address::from_str("2N3zXjbwdTcPsJiy8sUK9FhWJhqQCxA8Jjr").unwrap(), addr);
|
|
|
|
}
|
|
|
|
|
2018-03-14 03:53:03 +00:00
|
|
|
#[test]
|
|
|
|
fn test_p2wpkh () {
|
|
|
|
// stolen from Bitcoin transaction: b3c8c2b6cfc335abbcb2c7823a8453f55d64b2b5125a9a61e8737230cdb8ce20
|
2019-01-15 17:05:41 +00:00
|
|
|
let key = hex_key!("033bc8c83c52df5712229a2f72206d90192366c36428cb0c12b6af98324d97bfbc");
|
2018-03-14 03:53:03 +00:00
|
|
|
let addr = Address::p2wpkh(&key, Bitcoin);
|
|
|
|
assert_eq!(&addr.to_string(), "bc1qvzvkjn4q3nszqxrv3nraga2r822xjty3ykvkuw");
|
|
|
|
}
|
|
|
|
|
|
|
|
#[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");
|
|
|
|
}
|
|
|
|
|
2018-03-09 20:27:13 +00:00
|
|
|
#[test]
|
|
|
|
fn test_bip173_vectors() {
|
|
|
|
let addrstr = "BC1QW508D6QEJXTDG4Y5R3ZARVARY0C5XW7KV8F3T4";
|
|
|
|
let addr = Address::from_str(addrstr).unwrap();
|
|
|
|
assert_eq!(addr.network, Bitcoin);
|
|
|
|
assert_eq!(addr.script_pubkey(), hex_script!("0014751e76e8199196d454941c45d1b3a323f1433bd6"));
|
|
|
|
// skip round-trip because we'll serialize to lowercase which won't match
|
|
|
|
|
|
|
|
let addrstr = "tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k7";
|
|
|
|
let addr = Address::from_str(addrstr).unwrap();
|
|
|
|
assert_eq!(addr.network, Testnet);
|
|
|
|
assert_eq!(addr.script_pubkey(), hex_script!("00201863143c14c5166804bd19203356da136c985678cd4d27a1b8c6329604903262"));
|
|
|
|
assert_eq!(addr.to_string(), addrstr);
|
|
|
|
|
|
|
|
let addrstr = "tb1qqqqqp399et2xygdj5xreqhjjvcmzhxw4aywxecjdzew6hylgvsesrxh6hy";
|
|
|
|
let addr = Address::from_str(addrstr).unwrap();
|
|
|
|
assert_eq!(addr.network, Testnet);
|
|
|
|
assert_eq!(addr.script_pubkey(), hex_script!("0020000000c4a5cad46221b2a187905e5266362b99d5e91c6ce24d165dab93e86433"));
|
|
|
|
assert_eq!(addr.to_string(), addrstr);
|
|
|
|
|
2018-07-26 00:51:37 +00:00
|
|
|
let addrstr = "bcrt1q2nfxmhd4n3c8834pj72xagvyr9gl57n5r94fsl";
|
|
|
|
let addr = Address::from_str(addrstr).unwrap();
|
|
|
|
assert_eq!(addr.network, Regtest);
|
|
|
|
assert_eq!(addr.script_pubkey(), hex_script!("001454d26dddb59c7073c6a197946ea1841951fa7a74"));
|
|
|
|
assert_eq!(addr.to_string(), addrstr);
|
|
|
|
|
2018-03-09 20:27:13 +00:00
|
|
|
// bad vectors
|
|
|
|
let addrstr = "tc1qw508d6qejxtdg4y5r3zarvary0c5xw7kg3g4ty"; // invalid hrp
|
|
|
|
assert!(Address::from_str(addrstr).is_err());
|
|
|
|
|
|
|
|
let addrstr = "bc1qw508d6qejxtdg4y5r3zarvary0c5xw7kv8f3t5"; // invalid checksum
|
|
|
|
assert!(Address::from_str(addrstr).is_err());
|
|
|
|
|
|
|
|
let addrstr = "BC13W508D6QEJXTDG4Y5R3ZARVARY0C5XW7KN40WF2"; // invalid witness version
|
|
|
|
assert!(Address::from_str(addrstr).is_err());
|
|
|
|
|
|
|
|
let addrstr = "bc1rw5uspcuh"; // invalid program length
|
|
|
|
assert!(Address::from_str(addrstr).is_err());
|
|
|
|
|
|
|
|
let addrstr = "bc10w508d6qejxtdg4y5r3zarvary0c5xw7kw508d6qejxtdg4y5r3zarvary0c5xw7kw5rljs90"; // invalid program length
|
|
|
|
assert!(Address::from_str(addrstr).is_err());
|
|
|
|
|
|
|
|
let addrstr = "BC1QR508D6QEJXTDG4Y5R3ZARVARYV98GJ9P"; // invalid program length for wit v0
|
|
|
|
assert!(Address::from_str(addrstr).is_err());
|
|
|
|
|
|
|
|
let addrstr = "tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sL5k7"; // mixed case
|
|
|
|
assert!(Address::from_str(addrstr).is_err());
|
|
|
|
|
|
|
|
let addrstr = "bc1zw508d6qejxtdg4y5r3zarvaryvqyzf3du"; // zero padding of more than 4 bits
|
|
|
|
assert!(Address::from_str(addrstr).is_err());
|
|
|
|
|
|
|
|
let addrstr = "tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3pjxtptv"; // nonzero padding
|
|
|
|
assert!(Address::from_str(addrstr).is_err());
|
|
|
|
|
|
|
|
let addrstr = "bc1gmk9yu"; // empty data section
|
|
|
|
assert!(Address::from_str(addrstr).is_err());
|
2015-10-15 03:21:09 +00:00
|
|
|
}
|
2015-10-14 20:29:19 +00:00
|
|
|
|
2018-08-30 19:01:54 +00:00
|
|
|
#[test]
|
2019-03-26 16:05:51 +00:00
|
|
|
#[cfg(feature = "serde")]
|
2018-08-30 19:01:54 +00:00
|
|
|
fn test_json_serialize() {
|
2019-03-26 16:05:51 +00:00
|
|
|
use serde_json;
|
2018-08-30 19:01:54 +00:00
|
|
|
|
|
|
|
let addr = Address::from_str("132F25rTsvBdp9JzLLBHP5mvGY66i1xdiM").unwrap();
|
2019-03-26 16:05:51 +00:00
|
|
|
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();
|
2018-08-30 19:01:54 +00:00
|
|
|
assert_eq!(addr.to_string(), into.to_string());
|
|
|
|
assert_eq!(
|
|
|
|
into.script_pubkey(),
|
|
|
|
hex_script!("76a914162c5ea71c0b23f5b9022ef047c4a86470a5b07088ac")
|
|
|
|
);
|
|
|
|
|
|
|
|
let addr = Address::from_str("33iFwdLuRpW1uK1RTRqsoi8rR4NpDzk66k").unwrap();
|
2019-03-26 16:05:51 +00:00
|
|
|
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();
|
2018-08-30 19:01:54 +00:00
|
|
|
assert_eq!(addr.to_string(), into.to_string());
|
|
|
|
assert_eq!(
|
|
|
|
into.script_pubkey(),
|
|
|
|
hex_script!("a914162c5ea71c0b23f5b9022ef047c4a86470a5b07087")
|
|
|
|
);
|
|
|
|
|
|
|
|
let addr = Address::from_str("tb1qrp33g0q5c5txsp9arysrx4k6zdkfs4nce4xj0gdcccefvpysxf3q0sl5k7").unwrap();
|
2019-03-26 16:05:51 +00:00
|
|
|
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();
|
2018-08-30 19:01:54 +00:00
|
|
|
assert_eq!(addr.to_string(), into.to_string());
|
|
|
|
assert_eq!(
|
|
|
|
into.script_pubkey(),
|
|
|
|
hex_script!("00201863143c14c5166804bd19203356da136c985678cd4d27a1b8c6329604903262")
|
|
|
|
);
|
|
|
|
|
|
|
|
let addr = Address::from_str("bcrt1q2nfxmhd4n3c8834pj72xagvyr9gl57n5r94fsl").unwrap();
|
2019-03-26 16:05:51 +00:00
|
|
|
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();
|
2018-08-30 19:01:54 +00:00
|
|
|
assert_eq!(addr.to_string(), into.to_string());
|
|
|
|
assert_eq!(
|
|
|
|
into.script_pubkey(),
|
|
|
|
hex_script!("001454d26dddb59c7073c6a197946ea1841951fa7a74")
|
|
|
|
);
|
|
|
|
}
|
|
|
|
}
|