Enum Input

pub enum Input {
    PrevOut {
        outpoint: OutPoint,
        unlock_script: Script,
        sequence: u32,
    },
    Coinbase {
        height: Height,
        data: CoinbaseData,
        sequence: u32,
    },
}

A transparent input to a transaction.

Variants

PrevOut

A reference to an output of a previous transaction.

Fields

outpoint: OutPoint

The previous output transaction reference.

unlock_script: Script

The script that authorizes spending outpoint.

sequence: u32

The sequence number for the output.

Coinbase

New coins created by the block reward.

Fields

height: Height

The height of this block.

data: CoinbaseData

Free data inserted by miners after the block height.

sequence: u32

The sequence number for the output.

Implementations

impl Input

pub fn vec_strategy( ledger_state: &LedgerState, max_size: usize, ) -> BoxedStrategy<Vec<Self>>

Construct a strategy for creating valid-ish vecs of Inputs.

impl Input

pub fn new_coinbase( height: Height, data: Option<Vec<u8>>, sequence: Option<u32>, ) -> Input

Returns a new coinbase input for height with optional data and sequence.

Consensus

The combined serialized size of height and data can be at most 100 bytes.

A coinbase transaction script MUST have length in {2 .. 100} bytes.

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

Panics

If the coinbase data is greater than MAX_COINBASE_DATA_LEN.

pub fn extra_coinbase_data(&self) -> Option<&CoinbaseData>

Returns the extra coinbase data in this input, if it is an Input::Coinbase.

pub fn sequence(&self) -> u32

Returns the input’s sequence number.

pub fn set_sequence(&mut self, new_sequence: u32)

Sets the input’s sequence number.

Only for use in tests.

pub fn outpoint(&self) -> Option<OutPoint>

If this is a Input::PrevOut input, returns this input’s OutPoint. Otherwise, returns None.

pub fn set_outpoint(&mut self, new_outpoint: OutPoint)

Set this input’s OutPoint.

Should only be called on Input::PrevOut inputs.

Panics

If self is a coinbase input.

pub(crate) fn value_from_outputs( &self, outputs: &HashMap<OutPoint, Output>, ) -> Amount<NonNegative>

Get the value spent by this input, by looking up its OutPoint in outputs. See Self::value for details.

Panics

If the provided Outputs don’t have this input’s OutPoint.

pub fn value(&self, utxos: &HashMap<OutPoint, Utxo>) -> Amount<NonNegative>

Get the value spent by this input, by looking up its OutPoint in Utxos.

This amount is added to the transaction value pool by this input.

Panics

If the provided Utxos don’t have this input’s OutPoint.

pub fn value_from_ordered_utxos( &self, ordered_utxos: &HashMap<OutPoint, OrderedUtxo>, ) -> Amount<NonNegative>

Get the value spent by this input, by looking up its OutPoint in OrderedUtxos.

See Self::value for details.

Panics

If the provided OrderedUtxos don’t have this input’s OutPoint.

Trait Implementations

impl Arbitrary for Input

type Parameters = Option<Height>

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

type Strategy = BoxedStrategy<Input>

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

fn arbitrary_with(height: 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 Input

fn clone(&self) -> Input

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Input

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

Formats the value using the given formatter.

impl Display for Input

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

Formats the value using the given formatter.

impl PartialEq for Input

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

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 Input

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

If a transaction contains more inputs 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 ZcashDeserialize for Input

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

Try to read self from the given reader.

impl ZcashSerialize for Input

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

Serialize this transparent input.

Errors

Returns an error if the coinbase height is zero, and the coinbase data does not match the Zcash mainnet and testnet genesis coinbase data. (They are identical.)

This check is required, because the genesis block does not include an encoded coinbase height,

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 Input

impl StructuralPartialEq for Input