Enum miniscript::miniscript::astelem::AstElem

pub enum AstElem<P> {
    True,
    Pk(P),
    PkV(P),
    PkQ(P),
    PkW(P),
    Multi(usize, Vec<P>),
    MultiV(usize, Vec<P>),
    Time(u32),
    TimeV(u32),
    TimeF(u32),
    TimeE(u32),
    TimeW(u32),
    Hash(Hash),
    HashV(Hash),
    HashW(Hash),
    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

True

1

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

Time(u32)

<n> CHECKSEQUENCEVERIFY

TimeV(u32)

<n> CHECKSEQUENCEVERIFY DROP

TimeF(u32)

<n> CHECKSEQUENCEVERIFY 0NOTEQUAL

TimeE(u32)

DUP IF <n> CHECKSEQUENCEVERIFY DROP ENDIF

TimeW(u32)

SWAP DUP IF <n> CHECKSEQUENCEVERIFY DROP ENDIF

Hash(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

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.

pub fn script_size(&self) -> usize

Size, in bytes of the script-pubkey. If this Miniscript is used outside of segwit (e.g. in a bare or P2SH descriptor), this quantity should be multiplied by 4 to compute the weight.

In general, it is not recommended to use this function directly, but to instead call the corresponding function on a Descriptor, which will handle the segwit/non-segwit technicalities for you.

pub fn max_dissatisfaction_witness_elements(&self) -> usize

Maximum number of witness elements used to dissatisfy the Miniscript fragment. Used to estimate the weight of the VarInt that specifies this number in a serialized transaction.

Will panic if you give it a non-E non-W fragment.

pub fn max_dissatisfaction_size(&self, one_cost: usize) -> usize

Maximum dissatisfaction cost, in bytes, of a Miniscript fragment, if it is possible to compute this. This function should probably not ever be used directly. It is called from max_satisfaction_size.

Will panic if you give it a non-E non-W fragment.

pub fn max_satisfaction_witness_elements(&self) -> usize

Maximum number of witness elements used to satisfy the Miniscript fragment. Used to estimate the weight of the VarInt that specifies this number in a serialized transaction.

This number does not include the witness script itself, so 1 needs to be added to the final result.

pub fn max_satisfaction_size(&self, one_cost: usize) -> usize

Maximum size, in bytes, of a satisfying witness. For Segwit outputs one_cost should be set to 2, since the number 1 requires two bytes to encode. For non-segwit outputs one_cost should be set to 1, since OP_1 is available in scriptSigs.

In general, it is not recommended to use this function directly, but to instead call the corresponding function on a Descriptor, which will handle the segwit/non-segwit technicalities for you.

All signatures are assumed to be 73 bytes in size, including the length prefix (segwit) or push opcode (pre-segwit) and sighash postfix.

This function may panic on misformed Miniscript objects which do not correspond to semantically sane Scripts. (Such scripts should be rejected at parse time. Any exceptions are bugs.)

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, 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: Eq> Eq for AstElem<P>

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)

Restrict a value to a certain interval.

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: 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: 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> From<AstElem<P>> for Miniscript<P>

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

Performs the conversion.

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

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.