Enum zebra_chain::transparent::Address

pub enum Address {
    PayToScriptHash {
        network_kind: NetworkKind,
        script_hash: [u8; 20],
    },
    PayToPublicKeyHash {
        network_kind: NetworkKind,
        pub_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.

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 create_script_from_address(&self) -> Script

Given a transparent address (P2SH or a P2PKH), create a script that can be used in a coinbase transaction output.

Trait Implementations

impl Arbitrary for Address

type Parameters = ()

The type of parameters that arbitrary_with accepts for configuration of the generated Strategy. Parameters must implement Default.

fn arbitrary_with(_args: ()) -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self). The strategy is passed the arguments given in args.

type Strategy = BoxedStrategy<Address>

The type of Strategy used to generate values of type Self.

fn arbitrary() -> Self::Strategy

Generates a Strategy for producing arbitrary values of type the implementing type (Self).

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

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