Enum Terminal 

pub enum Terminal<'a, 'b> {
    ScriptHash(Box<'a, Terminal<'a, 'b>>),
    WitnessScriptHash(Box<'a, Terminal<'a, 'b>>),
    PublicKey(Key<'a>),
    PublicKeyHash(Key<'a>),
    WitnessPublicKeyHash(Key<'b>),
    Combo(Key<'a>),
    Multisig(Multikey<'a>),
    SortedMultisig(Multikey<'a>),
    Address(Address<'a>),
    RawScript(&'a [u8]),
    Taproot(Box<'a, Terminal<'a, 'b>>),
    Cosigner(Key<'a>),
}

Output descriptor element.

Variants

ScriptHash(Box<'a, Terminal<'a, 'b>>)

Script hash.

WitnessScriptHash(Box<'a, Terminal<'a, 'b>>)

Witness script hash.

PublicKey(Key<'a>)

Public key.

PublicKeyHash(Key<'a>)

Public key hash.

WitnessPublicKeyHash(Key<'b>)

Witness public key hash.

Combo(Key<'a>)

Unknown purpose.

It is not documented in the specification.

Warning: This is not defined in miniscript.

Multisig(Multikey<'a>)

Multiple signature checking.

SortedMultisig(Multikey<'a>)

Sorted (deterministic) multiple signature checking.

Address(Address<'a>)

A bare Bitcoin address.

RawScript(&'a [u8])

A raw script.

Taproot(Box<'a, Terminal<'a, 'b>>)

Taproot script.

Cosigner(Key<'a>)

Additional cosigner.

Warning: This is not defined in miniscript.

Trait Implementations

impl<'a, 'b> Debug for Terminal<'a, 'b>

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

Formats the value using the given formatter.

impl<'a, 'b, const N: usize> Decode<'b, &'a Arena<Terminal<'a, 'b>, N>> for Terminal<'a, 'b>

fn decode( d: &mut Decoder<'b>, ctx: &mut &'a TerminalContext<'a, 'b, N>, ) -> Result<Self, Error>

Decode a value using the given Decoder.

fn nil() -> Option<Self>

If possible, return a nil value of Self.

impl<'a, 'b, C> Encode<C> for Terminal<'a, 'b>

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<'a, 'b> PartialEq for Terminal<'a, 'b>

fn eq(&self, other: &Terminal<'a, 'b>) -> 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<'a, 'b> StructuralPartialEq for Terminal<'a, 'b>