Struct zebra_chain::transparent::Output

pub struct Output {
    pub value: Amount<NonNegative>,
    pub lock_script: Script,
}

A transparent output from a transaction.

The most fundamental building block of a transaction is a transaction output – the ZEC you own in your “wallet” is in fact a subset of unspent transaction outputs (or “UTXO“s) of the global UTXO set.

UTXOs are indivisible, discrete units of value which can only be consumed in their entirety. Thus, if I want to send you 1 ZEC and I only own one UTXO worth 2 ZEC, I would construct a transaction that spends my UTXO and sends 1 ZEC to you and 1 ZEC back to me (just like receiving change).

Fields

value: Amount<NonNegative>

Transaction value.

lock_script: Script

The lock script defines the conditions under which this output can be spent.

Implementations

impl Output

pub fn new_coinbase(amount: Amount<NonNegative>, lock_script: Script) -> Output

Returns a new coinbase output that pays amount using lock_script.

pub fn value(&self) -> Amount<NonNegative>

Get the value contained in this output. This amount is subtracted from the transaction value pool by this output.

pub fn address(&self, network: &Network) -> Option<Address>

Return the destination address from a transparent output.

Returns None if the address type is not valid or unrecognized.

Trait Implementations

impl Arbitrary for Output

type Parameters = (<Amount<NonNegative> as Arbitrary>::Parameters, <Script as Arbitrary>::Parameters)

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

type Strategy = Map<(<Amount<NonNegative> as Arbitrary>::Strategy, <Script as Arbitrary>::Strategy), fn(_: (Amount<NonNegative>, Script)) -> Output>

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

fn arbitrary_with(_top: Self::Parameters) -> Self::Strategy

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

fn arbitrary() -> Self::Strategy

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

impl Clone for Output

fn clone(&self) -> Output

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Output

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Output

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Hash for Output

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 Output

fn eq(&self, other: &Output) -> 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 Output

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TrustedPreallocate for Output

The maximum number of outputs in a valid Zcash on-chain transaction.

If a transaction contains more outputs than can fit in maximally large block, it might be valid on the network and in the mempool, but it can never be mined into a block. So rejecting these large edge-case transactions can never break consensus.

fn max_allocation() -> u64

Provides a loose upper bound on the size of the Vec<T: TrustedPreallocate> which can possibly be received from an honest peer.

impl TryFrom<&Output> for TxOut

Convert a Zebra transparent::Output into a librustzcash one.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(output: &Output) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<Output> for TxOut

Convert a Zebra transparent::Output into a librustzcash one.

type Error = Error

The type returned in the event of a conversion error.

fn try_from(output: Output) -> Result<Self, Self::Error>

Performs the conversion.

impl ZcashDeserialize for Output

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

Try to read self from the given reader.

impl ZcashSerialize for Output

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 Output

impl StructuralPartialEq for Output