Struct Output 

pub struct Output { /* private fields */ }

A transaction output, which comprises of at least an Address and a Value<u64>.

The value can be either explicit set using Self::new or defined to the minimum acceptable by the protocol using Self::to.

Optionally, one can attach an Datum and/or a PlutusScript via Self::with_datum/Self::with_datum_hash and Self::with_plutus_script respectively.

Native scripts as reference scripts aren't yet supported. Only Plutus scripts are.

Implementations

impl Output

pub fn new(address: Address<Any>, value: Value<u64>) -> Self

Construct a new output from an Address and a Value<u64>. See also Self::to for constructing a value without an explicit value.

pub fn to(address: Address<Any>) -> Self

Like Self::new, but assumes a minimum lovelace value as output. The value automatically adjusts based on the other Output’s elements (assets, scripts, etc..).

pub fn with_assets<AssetName>( self, assets: impl IntoIterator<Item = (Hash<28>, impl IntoIterator<Item = (AssetName, u64)>)>, ) -> Self

where AssetName: AsRef<[u8]>,

Attach assets to the output, while preserving the lovelace value.

pub fn with_plutus_script(self, plutus_script: PlutusScript) -> Self

Attach a reference script to the output.

pub fn with_datum_hash(self, hash: Hash<32>) -> Self

Attach a datum reference as Hash<32> to the output.

pub fn with_datum(self, data: PlutusData<'static>) -> Self

Attach a plain PlutusData datum to the output.

impl Output

pub fn address(&self) -> &Address<Any>

pub fn value(&self) -> &Value<u64>

pub fn script(&self) -> Option<&PlutusScript>

pub fn datum(&self) -> Option<&Datum>

pub fn min_acceptable_value(&self) -> u64

The minimum quantity of lovelace acceptable to carry this output. Address’ delegation, assets, scripts and datums may increase this value.

examples

// Simple, undelegated address. About as low as we can go.
assert_eq!(
  output!("addr1v83gkkw3nqzakg5xynlurqcfqhgd65vkfvf5xv8tx25ufds2yvy2h")
    .min_acceptable_value(),
  857690,
);

// Address with delegation.
assert_eq!(
  output!("addr1qytp6yfl9wwamcqu3j5kqhjz8hlgkt62nd82d837g9dlsmn85wjc8sjtq2wqxfmahmpn6h85y0ug7mzclf2jl4zyt3vq587s69")
    .min_acceptable_value(),
  978370,
);

// Undelegated address with some native assets.
assert_eq!(
  output!("addr1v83gkkw3nqzakg5xynlurqcfqhgd65vkfvf5xv8tx25ufds2yvy2h")
    .with_assets([
        (
            hash!("279c909f348e533da5808898f87f9a14bb2c3dfbbacccd631d927a3f"),
            [(b"SNEK".to_vec(), 1_000_000_000)]
        )
    ])
    .min_acceptable_value(),
  1043020,
);

// Undelegated address with some inline datum.
assert_eq!(
  output!("addr1v83gkkw3nqzakg5xynlurqcfqhgd65vkfvf5xv8tx25ufds2yvy2h")
    .with_datum(PlutusData::list([
        PlutusData::integer(14),
        PlutusData::integer(42),
        PlutusData::bytes(b"foobar"),
    ]))
    .min_acceptable_value(),
  935270,
);

// Undelegated address with some datum hash.
assert_eq!(
  output!("addr1v83gkkw3nqzakg5xynlurqcfqhgd65vkfvf5xv8tx25ufds2yvy2h")
    .with_datum_hash(hash!("279c909f348e533da5808898f87f9a14bb2c3dfbbacccd631d927a3f00000000"))
    .min_acceptable_value(),
  1017160,
);

Trait Implementations

impl Clone for Output

fn clone(&self) -> Output

Returns a duplicate 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<'d, C> Decode<'d, C> for Output

fn decode(d: &mut Decoder<'d>, ctx: &mut C) -> Result<Self, Error>

Decode a value using the given Decoder.

fn nil() -> Option<Self>

If possible, return a nil value of Self.

impl Display for Output

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

Formats the value using the given formatter.

impl<C> Encode<C> for Output

fn encode<W: Write>( &self, e: &mut Encoder<W>, ctx: &mut C, ) -> Result<(), Error<W::Error>>

Encode a value of this type using the given Encoder.

fn is_nil(&self) -> bool

Is this value of Self a nil value?

impl From<&Output> for TransactionOutput

fn from(output: &Output) -> Self

Converts to this type from the input type.

impl From<Output> for TransactionOutput

fn from(this: Output) -> Self

Converts to this type from the input type.

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 TryFrom<PseudoTransactionOutput<PseudoPostAlonzoTransactionOutput<Value, PseudoDatumOption<PlutusData>, PseudoScript<NativeScript>>>> for Output

type Error = Error

The type returned in the event of a conversion error.

fn try_from(source: TransactionOutput) -> Result<Self>

Performs the conversion.

impl Eq for Output

impl StructuralPartialEq for Output