Enum miniscript::miniscript::astelem::AstElem

pub enum AstElem<P> {
    Pk(P),
    PkV(P),
    PkQ(P),
    PkW(P),
    Multi(usize, Vec<P>),
    MultiV(usize, Vec<P>),
    TimeT(u32),
    TimeV(u32),
    TimeF(u32),
    Time(u32),
    TimeW(u32),
    HashT(Hash),
    HashV(Hash),
    HashW(Hash),
    True(Box<AstElem<P>>),
    Wrap(Box<AstElem<P>>),
    Likely(Box<AstElem<P>>),
    Unlikely(Box<AstElem<P>>),
    AndCat(Box<AstElem<P>>, Box<AstElem<P>>),
    AndBool(Box<AstElem<P>>, Box<AstElem<P>>),
    AndCasc(Box<AstElem<P>>, Box<AstElem<P>>),
    OrBool(Box<AstElem<P>>, Box<AstElem<P>>),
    OrCasc(Box<AstElem<P>>, Box<AstElem<P>>),
    OrCont(Box<AstElem<P>>, Box<AstElem<P>>),
    OrKey(Box<AstElem<P>>, Box<AstElem<P>>),
    OrKeyV(Box<AstElem<P>>, Box<AstElem<P>>),
    OrIf(Box<AstElem<P>>, Box<AstElem<P>>),
    OrIfV(Box<AstElem<P>>, Box<AstElem<P>>),
    OrNotif(Box<AstElem<P>>, Box<AstElem<P>>),
    Thresh(usize, Vec<AstElem<P>>),
    ThreshV(usize, Vec<AstElem<P>>),
}

All AST elements

Variants

Pk(P)

<key> CHECKSIG

PkV(P)

<key> CHECKSIGVERIFY

PkQ(P)

<key>

PkW(P)

SWAP <key> CHECKSIG

Multi(usize, Vec<P>)

<k> <keys...> <n> CHECKMULTISIG

MultiV(usize, Vec<P>)

<k> <keys...> <n> CHECKMULTISIGVERIFY

TimeT(u32)

<n> CHECKSEQUENCEVERIFY

TimeV(u32)

<n> CHECKSEQUENCEVERIFY DROP

TimeF(u32)

<n> CHECKSEQUENCEVERIFY 0NOTEQUAL

Time(u32)

DUP IF <n> CHECKSEQUENCEVERIFY DROP ENDIF

TimeW(u32)

SWAP DUP IF <n> CHECKSEQUENCEVERIFY DROP ENDIF

HashT(Hash)

SIZE 32 EQUALVERIFY SHA256 <hash> EQUAL

HashV(Hash)

SIZE 32 EQUALVERIFY SHA256 <hash> EQUALVERIFY

HashW(Hash)

SWAP SIZE 0NOTEQUAL IF SIZE 32 EQUALVERIFY SHA256 <hash> EQUALVERIFY 1 ENDIF

True(Box<AstElem<P>>)

<V> 1

Wrap(Box<AstElem<P>>)

TAS <E> FAS

Likely(Box<AstElem<P>>)

NOTIF <F> ELSE 0 ENDIF

Unlikely(Box<AstElem<P>>)

IF <F> ELSE 0 ENDIF

AndCat(Box<AstElem<P>>, Box<AstElem<P>>)

<V> <T/V/F/Q>

AndBool(Box<AstElem<P>>, Box<AstElem<P>>)

<E> <W> BOOLAND

AndCasc(Box<AstElem<P>>, Box<AstElem<P>>)

<E> NOTIF 0 ELSE <F> ENDIF

OrBool(Box<AstElem<P>>, Box<AstElem<P>>)

<E> <W> BoolOr

OrCasc(Box<AstElem<P>>, Box<AstElem<P>>)

<E> IFDUP NOTIF <T/E> ENDIF

OrCont(Box<AstElem<P>>, Box<AstElem<P>>)

<E> NOTIF <V> ENDIF

OrKey(Box<AstElem<P>>, Box<AstElem<P>>)

IF <Q> ELSE <Q> ENDIF CHECKSIG

OrKeyV(Box<AstElem<P>>, Box<AstElem<P>>)

IF <Q> ELSE <Q> ENDIF CHECKSIGVERIFY

OrIf(Box<AstElem<P>>, Box<AstElem<P>>)

IF <sub1> ELSE <sub2> ENDIF for many choices of sub1 and sub2

OrIfV(Box<AstElem<P>>, Box<AstElem<P>>)

IF <T> ELSE <T> ENDIF VERIFY

OrNotif(Box<AstElem<P>>, Box<AstElem<P>>)

NOTIF <F> ELSE <E> ENDIF

Thresh(usize, Vec<AstElem<P>>)

<E> (<W> ADD)* <n> EQUAL

ThreshV(usize, Vec<AstElem<P>>)

<E> (<W> ADD)* <n> EQUALVERIFY

Methods

impl<P> AstElem<P>

pub fn is_e(&self) -> bool

Does the element satisfy the "expression" calling convention?

pub fn is_q(&self) -> bool

Does the element satisfy the "queue" calling convention?

pub fn is_w(&self) -> bool

Does the element satisfy the "wrapped" calling convention?

pub fn is_f(&self) -> bool

Does the element satisfy the "forced" calling convention?

pub fn is_v(&self) -> bool

Does the element satisfy the "verify" calling convention?

pub fn is_t(&self) -> bool

Does the element satisfy the "toplevel" calling convention?

pub fn translate<Func, Q, Error>(
    &self,
    translatefn: &mut Func
) -> Result<AstElem<Q>, Error> where
    Func: FnMut(&P) -> Result<Q, Error>, 

Convert an AST element with one public key type to one of another public key type

impl<P: Clone> AstElem<P>

pub fn abstract_policy(&self) -> AbstractPolicy<P>

Abstract the script into an "abstract policy" which can be filtered and analyzed

pub fn public_keys(&self) -> Vec<P>

Return a list of all public keys which might contribute to satisfaction of the scriptpubkey

impl<P: ToPublicKey> AstElem<P>

pub fn encode(&self, builder: Builder) -> Builder

Encode the element as a fragment of Bitcoin Script. The inverse function, from Script to an AST element, is implemented in the parse module.

Trait Implementations

impl<P: ToPublicKey> Satisfiable<P> for AstElem<P>

fn satisfy<F, H>(
    &self,
    keyfn: Option<&mut F>,
    hashfn: Option<&mut H>,
    age: u32
) -> Result<Vec<Vec<u8>>, Error> where
    F: FnMut(&P) -> Option<(Signature, Option<SigHashType>)>,
    H: FnMut(Hash) -> Option<[u8; 32]>, 

Attempt to produce a witness that satisfies the AST element

impl<P: ToPublicKey> Dissatisfiable<P> for AstElem<P>

fn dissatisfy(&self) -> Vec<Vec<u8>>

For AST elements satisfying the "expression" and "wrapped" calling conventions, produce a dissatisfying witness. For other elements, panic.

impl<P: FromStr> FromTree for AstElem<P> where
    <P as FromStr>::Err: ToString, 

fn from_tree(top: &Tree) -> Result<AstElem<P>, Error>

impl<P: PartialOrd> PartialOrd<AstElem<P>> for AstElem<P>

fn partial_cmp(&self, other: &AstElem<P>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &AstElem<P>) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &AstElem<P>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &AstElem<P>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &AstElem<P>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<P: PartialEq> PartialEq<AstElem<P>> for AstElem<P>

fn eq(&self, other: &AstElem<P>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &AstElem<P>) -> bool

This method tests for !=.

impl<P> From<AstElem<P>> for Miniscript<P>

fn from(t: AstElem<P>) -> Miniscript<P>

Performs the conversion.

impl<P: Clone> Clone for AstElem<P>

fn clone(&self) -> AstElem<P>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<P: Ord> Ord for AstElem<P>

fn cmp(&self, other: &AstElem<P>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

🔬 This is a nightly-only experimental API. (clamp)

Returns max if self is greater than max, and min if self is less than min. Otherwise this will return self. Panics if min > max.

impl<P: Eq> Eq for AstElem<P>

impl<P: Display> Display for AstElem<P>

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

Formats the value using the given formatter.

impl<P: Debug> Debug for AstElem<P>

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

Formats the value using the given formatter.