Struct bitcoincash::util::address::Address

pub struct Address {
    pub payload: Payload,
    pub network: Network,
}

A Bitcoin address.

Relevant BIPs

• BIP13 - Address Format for pay-to-script-hash
• BIP16 - Pay to Script Hash
• BIP141 - Segregated Witness (Consensus layer)
• BIP142 - Address Format for Segregated Witness
• BIP341 - Taproot: SegWit version 1 spending rules
• BIP350 - Bech32m format for v1+ witness addresses

Fields

payload: Payload

The type of the address.

network: Network

The network on which this address is usable.

Implementations

impl Address

pub fn p2pkh(pk: &PublicKey, network: Network) -> Address

Creates a pay to (compressed) public key hash address from a public key.

This is the preferred non-witness type address.

Examples found in repository

src/util/misc.rs (line 164)

        pub fn is_signed_by_address<C: secp256k1::Verification>(
            &self,
            secp_ctx: &secp256k1::Secp256k1<C>,
            address: &Address,
            msg_hash: sha256d::Hash
        ) -> Result<bool, MessageSignatureError> {
            match address.address_type() {
                Some(AddressType::P2pkh) => {
                    let pubkey = self.recover_pubkey(secp_ctx, msg_hash)?;
                    Ok(*address == Address::p2pkh(&pubkey, address.network))
                }
                Some(address_type) => Err(MessageSignatureError::UnsupportedAddressType(address_type)),
                None => Ok(false),
            }
        }

pub fn p2sh(script: &Script, network: Network) -> Result<Address, Error>

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.

pub fn p2wpkh(pk: &PublicKey, network: Network) -> Result<Address, Error>

Creates 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.

Errors

Will only return an error if an uncompressed public key is provided.

pub fn p2shwpkh(pk: &PublicKey, network: Network) -> Result<Address, Error>

Creates 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.

Errors

Will only return an Error if an uncompressed public key is provided.

pub fn p2wsh(script: &Script, network: Network) -> Address

Creates a witness pay to script hash address.

pub fn p2shwsh(script: &Script, network: Network) -> Address

Creates 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 p2tr<C: Verification>(
    secp: &Secp256k1<C>,
    internal_key: UntweakedPublicKey,
    merkle_root: Option<TapBranchHash>,
    network: Network
) -> Address

Creates a pay to taproot address from an untweaked key.

pub fn p2tr_tweaked(output_key: TweakedPublicKey, network: Network) -> Address

Creates a pay to taproot address from a pre-tweaked output key.

This method is not recommended for use, Address::p2tr() should be used where possible.

pub fn address_type(&self) -> Option<AddressType>

Gets the address type of the address.

Returns

None if unknown, non-standard or related to the future witness version.

Examples found in repository

src/util/address.rs (line 767)

    pub fn is_standard(&self) -> bool {
        self.address_type().is_some()
    }

    /// Constructs an [`Address`] from an output script (`scriptPubkey`).
    pub fn from_script(script: &script::Script, network: Network) -> Result<Address, Error> {
        Ok(Address {
            payload: Payload::from_script(script)?,
            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)
    }

    /// Parsed addresses do not always have *one* network. The problem is that legacy testnet,
    /// regtest and signet addresse use the same prefix instead of multiple different ones. When
    /// parsing, such addresses are always assumed to be testnet addresses (the same is true for
    /// bech32 signet addresses). So if one wants to check if an address belongs to a certain
    /// network a simple comparison is not enough anymore. Instead this function can be used.
    ///
    /// ```rust
    /// use bitcoincash::{Address, Network};
    ///
    /// let address: Address = "2N83imGV3gPwBzKJQvWJ7cRUY2SpUyU6A5e".parse().unwrap();
    /// assert!(address.is_valid_for_network(Network::Testnet));
    /// assert!(address.is_valid_for_network(Network::Regtest));
    /// assert!(address.is_valid_for_network(Network::Scalenet));
    ///
    /// assert_eq!(address.is_valid_for_network(Network::Bitcoin), false);
    ///
    /// let address: Address = "32iVBEu4dxkUQk9dJbZUiBiQdmypcEyJRf".parse().unwrap();
    /// assert!(address.is_valid_for_network(Network::Bitcoin));
    /// assert_eq!(address.is_valid_for_network(Network::Testnet), false);
    /// ```
    pub fn is_valid_for_network(&self, network: Network) -> bool {
        let is_legacy = match self.address_type() {
            Some(AddressType::P2pkh) | Some(AddressType::P2sh) => true,
            _ => false
        };

        match (self.network, network) {
            (a, b) if a == b => true,
            (Network::Bitcoin, _) | (_, Network::Bitcoin) => false,
            (Network::Regtest, _) | (_, Network::Regtest) if !is_legacy => false,
            (Network::Testnet, _) | (Network::Testnet4, _) | (Network::Regtest, _) | (Network::Scalenet, _) | (Network::Chipnet, _) => true
        }
    }

src/util/misc.rs (line 161)

        pub fn is_signed_by_address<C: secp256k1::Verification>(
            &self,
            secp_ctx: &secp256k1::Secp256k1<C>,
            address: &Address,
            msg_hash: sha256d::Hash
        ) -> Result<bool, MessageSignatureError> {
            match address.address_type() {
                Some(AddressType::P2pkh) => {
                    let pubkey = self.recover_pubkey(secp_ctx, msg_hash)?;
                    Ok(*address == Address::p2pkh(&pubkey, address.network))
                }
                Some(address_type) => Err(MessageSignatureError::UnsupportedAddressType(address_type)),
                None => Ok(false),
            }
        }

pub fn is_standard(&self) -> bool

Checks 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 from_script(script: &Script, network: Network) -> Result<Address, Error>

Constructs an Address from an output script (scriptPubkey).

pub fn script_pubkey(&self) -> Script

Generates a script pubkey spending to this address.

pub fn to_qr_uri(&self) -> String

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 is_valid_for_network(&self, network: Network) -> bool

Parsed addresses do not always have one network. The problem is that legacy testnet, regtest and signet addresse use the same prefix instead of multiple different ones. When parsing, such addresses are always assumed to be testnet addresses (the same is true for bech32 signet addresses). So if one wants to check if an address belongs to a certain network a simple comparison is not enough anymore. Instead this function can be used.

use bitcoincash::{Address, Network};

let address: Address = "2N83imGV3gPwBzKJQvWJ7cRUY2SpUyU6A5e".parse().unwrap();
assert!(address.is_valid_for_network(Network::Testnet));
assert!(address.is_valid_for_network(Network::Regtest));
assert!(address.is_valid_for_network(Network::Scalenet));

assert_eq!(address.is_valid_for_network(Network::Bitcoin), false);

let address: Address = "32iVBEu4dxkUQk9dJbZUiBiQdmypcEyJRf".parse().unwrap();
assert!(address.is_valid_for_network(Network::Bitcoin));
assert_eq!(address.is_valid_for_network(Network::Testnet), false);

pub fn is_related_to_pubkey(&self, pubkey: &PublicKey) -> bool

Returns true if the given pubkey is directly related to the address payload.

This is determined by directly comparing the address payload with either the hash of the given public key or the segwit redeem hash generated from the given key. For taproot addresses, the supplied key is assumed to be tweaked

pub fn is_related_to_xonly_pubkey(&self, xonly_pubkey: &XOnlyPublicKey) -> bool

Returns true if the supplied xonly public key can be used to derive the address.

This will only work for Taproot addresses. The Public Key is assumed to have already been tweaked.

Trait Implementations

impl Clone for Address

fn clone(&self) -> Address

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Address

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Address

Available on crate feature serde only.

fn deserialize<D>(deserializer: D) -> Result<Address, D::Error>where
    D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Address

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl FromStr for Address

type Err = Error

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Address, Error>

Parses a string s to return a value of this type.

impl Hash for Address

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,
    Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Address

fn cmp(&self, other: &Address) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere
    Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere
    Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl PartialEq<Address> for Address

fn eq(&self, other: &Address) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd<Address> for Address

fn partial_cmp(&self, other: &Address) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Address

Available on crate feature serde only.

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>where
    S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for Address

impl StructuralEq for Address

impl StructuralPartialEq for Address