Enum Address

pub enum Address {
    PayToScriptHash {
        network_kind: NetworkKind,
        script_hash: [u8; 20],
    },
    PayToPublicKeyHash {
        network_kind: NetworkKind,
        pub_key_hash: [u8; 20],
    },
    Tex {
        network_kind: NetworkKind,
        validating_key_hash: [u8; 20],
    },
}

Transparent Zcash Addresses

In Bitcoin a single byte is used for the version field identifying the address type. In Zcash two bytes are used. For addresses on the production network, this and the encoded length cause the first two characters of the Base58Check encoding to be fixed as “t3” for P2SH addresses, and as “t1” for P2PKH addresses. (This does not imply that a transparent Zcash address can be parsed identically to a Bitcoin address just by removing the “t”.)

https://zips.z.cash/protocol/protocol.pdf#transparentaddrencoding

Variants

PayToScriptHash

P2SH (Pay to Script Hash) addresses

Fields

network_kind: NetworkKind

Production, test, or other network

script_hash: [u8; 20]

20 bytes specifying a script hash.

PayToPublicKeyHash

P2PKH (Pay to Public Key Hash) addresses

Fields

network_kind: NetworkKind

Production, test, or other network

pub_key_hash: [u8; 20]

20 bytes specifying a public key hash, which is a RIPEMD-160 hash of a SHA-256 hash of a compressed ECDSA key encoding.

Tex

Transparent-Source-Only Address.

https://zips.z.cash/zip-0320.html

Fields

network_kind: NetworkKind

Production, test, or other network

validating_key_hash: [u8; 20]

20 bytes specifying the validating key hash.

Implementations

impl Address

pub fn from_pub_key_hash( network_kind: NetworkKind, pub_key_hash: [u8; 20], ) -> Self

Create an address for the given public key hash and network.

pub fn from_script_hash( network_kind: NetworkKind, script_hash: [u8; 20], ) -> Self

Create an address for the given script hash and network.

pub fn network_kind(&self) -> NetworkKind

Returns the network kind for this address.

pub fn is_script_hash(&self) -> bool

Returns true if the address is PayToScriptHash, and false if it is PayToPublicKeyHash.

pub fn hash_bytes(&self) -> [u8; 20]

Returns the hash bytes for this address, regardless of the address type.

Correctness

Use ZcashSerialize and ZcashDeserialize for consensus-critical serialization.

pub fn script(&self) -> Script

Turns the address into the scriptPubKey script that can be used in a coinbase output.

TEX addresses are not supported and return an empty script.

pub fn from_tex( network_kind: NetworkKind, validating_key_hash: [u8; 20], ) -> Self

Create a TEX address from the given network kind and validating key hash.

Trait Implementations

impl Clone for Address

fn clone(&self) -> Address

Returns a duplicate 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

where Self: FromStr, <Self as FromStr>::Err: Display,

fn deserialize<__D>(deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Address

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

Formats the value using the given formatter.

impl From<Address> for ZcashAddress

fn from(taddr: Address) -> Self

Converts to this type from the input type.

impl FromStr for Address

type Err = SerializationError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

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 PartialEq for Address

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl Serialize for Address

where Self: Display,

fn serialize<__S>(&self, serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl ZcashDeserialize for Address

fn zcash_deserialize<R: Read>(reader: R) -> Result<Self, SerializationError>

Try to read self from the given reader.

impl ZcashSerialize for Address

fn zcash_serialize<W: Write>(&self, writer: W) -> Result<(), Error>

Write self to the given writer using the canonical format.

fn zcash_serialize_to_vec(&self) -> Result<Vec<u8>, Error>

Helper function to construct a vec to serialize the current struct into

fn zcash_serialized_size(&self) -> usize

Get the size of self by using a fake writer.

impl Eq for Address

impl StructuralPartialEq for Address