Enum Terminal

pub enum Terminal<Pk: MiniscriptKey, Ctx: ScriptContext, Ext: Extension = NoExt> {
    True,
    False,
    PkK(Pk),
    PkH(Pk),
    RawPkH(Hash),
    After(AbsLockTime),
    Older(Sequence),
    Sha256(Pk::Sha256),
    Hash256(Pk::Hash256),
    Ripemd160(Pk::Ripemd160),
    Hash160(Pk::Hash160),
    Alt(Arc<Miniscript<Pk, Ctx, Ext>>),
    Swap(Arc<Miniscript<Pk, Ctx, Ext>>),
    Check(Arc<Miniscript<Pk, Ctx, Ext>>),
    DupIf(Arc<Miniscript<Pk, Ctx, Ext>>),
    Verify(Arc<Miniscript<Pk, Ctx, Ext>>),
    NonZero(Arc<Miniscript<Pk, Ctx, Ext>>),
    ZeroNotEqual(Arc<Miniscript<Pk, Ctx, Ext>>),
    AndV(Arc<Miniscript<Pk, Ctx, Ext>>, Arc<Miniscript<Pk, Ctx, Ext>>),
    AndB(Arc<Miniscript<Pk, Ctx, Ext>>, Arc<Miniscript<Pk, Ctx, Ext>>),
    AndOr(Arc<Miniscript<Pk, Ctx, Ext>>, Arc<Miniscript<Pk, Ctx, Ext>>, Arc<Miniscript<Pk, Ctx, Ext>>),
    OrB(Arc<Miniscript<Pk, Ctx, Ext>>, Arc<Miniscript<Pk, Ctx, Ext>>),
    OrD(Arc<Miniscript<Pk, Ctx, Ext>>, Arc<Miniscript<Pk, Ctx, Ext>>),
    OrC(Arc<Miniscript<Pk, Ctx, Ext>>, Arc<Miniscript<Pk, Ctx, Ext>>),
    OrI(Arc<Miniscript<Pk, Ctx, Ext>>, Arc<Miniscript<Pk, Ctx, Ext>>),
    Thresh(usize, Vec<Arc<Miniscript<Pk, Ctx, Ext>>>),
    Multi(usize, Vec<Pk>),
    MultiA(usize, Vec<Pk>),
    Ext(Ext),
}

All AST elements.

This variant is the inner Miniscript variant that allows the user to bypass some of the miniscript rules. You should never construct Terminal directly. This is only exposed to external users to allow matching on the Miniscript.

The average user should always use the Descriptor APIs. Advanced users who want deal with Miniscript ASTs should use the Miniscript APIs.

Variants

True

1

False

0

PkK(Pk)

<key>

PkH(Pk)

DUP HASH160 <keyhash> EQUALVERIFY

RawPkH(Hash)

Only for parsing PkH for Script. These raw descriptors are not yet specified in miniscript. We only this variant internally for inferring miniscripts from raw Scripts. It is not possible to construct this variant from any of the Miniscript APIs. We don’t have a generic over here because we don’t want to user to have any abstract reasoning over raw descriptors.

After(AbsLockTime)

n CHECKLOCKTIMEVERIFY

Older(Sequence)

n CHECKSEQUENCEVERIFY

Sha256(Pk::Sha256)

SIZE 32 EQUALVERIFY SHA256 <hash> EQUAL

Hash256(Pk::Hash256)

SIZE 32 EQUALVERIFY HASH256 <hash> EQUAL

Ripemd160(Pk::Ripemd160)

SIZE 32 EQUALVERIFY RIPEMD160 <hash> EQUAL

Hash160(Pk::Hash160)

SIZE 32 EQUALVERIFY HASH160 <hash> EQUAL

Alt(Arc<Miniscript<Pk, Ctx, Ext>>)

TOALTSTACK [E] FROMALTSTACK

Swap(Arc<Miniscript<Pk, Ctx, Ext>>)

SWAP [E1]

Check(Arc<Miniscript<Pk, Ctx, Ext>>)

[Kt]/[Ke] CHECKSIG

DupIf(Arc<Miniscript<Pk, Ctx, Ext>>)

DUP IF [V] ENDIF

Verify(Arc<Miniscript<Pk, Ctx, Ext>>)

[T] VERIFY

NonZero(Arc<Miniscript<Pk, Ctx, Ext>>)

SIZE 0NOTEQUAL IF [Fn] ENDIF

ZeroNotEqual(Arc<Miniscript<Pk, Ctx, Ext>>)

[X] 0NOTEQUAL

AndV(Arc<Miniscript<Pk, Ctx, Ext>>, Arc<Miniscript<Pk, Ctx, Ext>>)

[V] [T]/[V]/[F]/[Kt]

AndB(Arc<Miniscript<Pk, Ctx, Ext>>, Arc<Miniscript<Pk, Ctx, Ext>>)

[E] [W] BOOLAND

AndOr(Arc<Miniscript<Pk, Ctx, Ext>>, Arc<Miniscript<Pk, Ctx, Ext>>, Arc<Miniscript<Pk, Ctx, Ext>>)

[various] NOTIF [various] ELSE [various] ENDIF

OrB(Arc<Miniscript<Pk, Ctx, Ext>>, Arc<Miniscript<Pk, Ctx, Ext>>)

[E] [W] BOOLOR

OrD(Arc<Miniscript<Pk, Ctx, Ext>>, Arc<Miniscript<Pk, Ctx, Ext>>)

[E] IFDUP NOTIF [T]/[E] ENDIF

OrC(Arc<Miniscript<Pk, Ctx, Ext>>, Arc<Miniscript<Pk, Ctx, Ext>>)

[E] NOTIF [V] ENDIF

OrI(Arc<Miniscript<Pk, Ctx, Ext>>, Arc<Miniscript<Pk, Ctx, Ext>>)

IF [various] ELSE [various] ENDIF

Thresh(usize, Vec<Arc<Miniscript<Pk, Ctx, Ext>>>)

[E] ([W] ADD)* k EQUAL

Multi(usize, Vec<Pk>)

k (<key>)* n CHECKMULTISIG

MultiA(usize, Vec<Pk>)

<key> CHECKSIG (<key> CHECKSIGADD)*(n-1) k NUMEQUAL

Ext(Ext)

Extensions

Implementations

impl<Pk: MiniscriptKey, Ctx: ScriptContext, Ext: Extension> Terminal<Pk, Ctx, Ext>

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

where Pk: ToPublicKey, Ext: ParseableExt,

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.

Trait Implementations

impl<Pk: Clone + MiniscriptKey, Ctx: Clone + ScriptContext, Ext: Clone + Extension> Clone for Terminal<Pk, Ctx, Ext>

where Pk::Sha256: Clone, Pk::Hash256: Clone, Pk::Ripemd160: Clone, Pk::Hash160: Clone,

fn clone(&self) -> Terminal<Pk, Ctx, Ext>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Pk, Ctx, Ext> Debug for Terminal<Pk, Ctx, Ext>

where Pk: MiniscriptKey, Ctx: ScriptContext, Ext: Extension,

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

Formats the value using the given formatter.

impl<Pk, Ctx, Ext> Display for Terminal<Pk, Ctx, Ext>

where Pk: MiniscriptKey, Ctx: ScriptContext, Ext: Extension,

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

Formats the value using the given formatter.

impl<Pk, Ctx, Ext> ForEachKey<Pk> for Terminal<Pk, Ctx, Ext>

where Pk: MiniscriptKey, Ctx: ScriptContext, Ext: Extension,

fn for_each_key<'a, F: FnMut(&'a Pk) -> bool>(&'a self, pred: F) -> bool

where Pk: 'a,

Run a predicate on every key in the descriptor, returning whether the predicate returned true for every key

fn for_any_key<'a, F>(&'a self, pred: F) -> bool

where F: FnMut(&'a Pk) -> bool, Pk: 'a,

Run a predicate on every key in the descriptor, returning whether the predicate returned true for any key

impl<Pk, Ctx, Ext> FromTree for Terminal<Pk, Ctx, Ext>

where Pk: FromStrKey, Ctx: ScriptContext, Ext: Extension,

fn from_tree(top: &Tree<'_>) -> Result<Terminal<Pk, Ctx, Ext>, Error>

Extract a structure from Tree representation

impl<Pk: Hash + MiniscriptKey, Ctx: Hash + ScriptContext, Ext: Hash + Extension> Hash for Terminal<Pk, Ctx, Ext>

where Pk::Sha256: Hash, Pk::Hash256: Hash, Pk::Ripemd160: Hash, Pk::Hash160: Hash,

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<Pk, Ctx, Ext> Liftable<Pk> for Terminal<Pk, Ctx, Ext>

where Pk: MiniscriptKey, Ctx: ScriptContext, Ext: Extension,

fn lift(&self) -> Result<Semantic<Pk>, Error>

Convert the object into an abstract policy

impl<Pk: Ord + MiniscriptKey, Ctx: Ord + ScriptContext, Ext: Ord + Extension> Ord for Terminal<Pk, Ctx, Ext>

where Pk::Sha256: Ord, Pk::Hash256: Ord, Pk::Ripemd160: Ord, Pk::Hash160: Ord,

fn cmp(&self, other: &Terminal<Pk, Ctx, Ext>) -> Ordering

This method returns an Ordering between self and other.

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

where Self: Sized,

Compares and returns the maximum of two values.

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

where Self: Sized,

Compares and returns the minimum of two values.

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

where Self: Sized,

Restrict a value to a certain interval.

impl<Pk: PartialEq + MiniscriptKey, Ctx: PartialEq + ScriptContext, Ext: PartialEq + Extension> PartialEq for Terminal<Pk, Ctx, Ext>

where Pk::Sha256: PartialEq, Pk::Hash256: PartialEq, Pk::Ripemd160: PartialEq, Pk::Hash160: PartialEq,

fn eq(&self, other: &Terminal<Pk, Ctx, Ext>) -> 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<Pk: PartialOrd + MiniscriptKey, Ctx: PartialOrd + ScriptContext, Ext: PartialOrd + Extension> PartialOrd for Terminal<Pk, Ctx, Ext>

where Pk::Sha256: PartialOrd, Pk::Hash256: PartialOrd, Pk::Ripemd160: PartialOrd, Pk::Hash160: PartialOrd,

fn partial_cmp(&self, other: &Terminal<Pk, Ctx, Ext>) -> Option<Ordering>

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

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

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

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

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

impl<Pk, Ctx, Ext, QExt> TranslateExt<Ext, QExt> for Terminal<Pk, Ctx, Ext>

where Pk: MiniscriptKey, Ctx: ScriptContext, Ext: Extension + TranslateExt<Ext, QExt, Output = QExt>, QExt: Extension,

type Output = Terminal<Pk, Ctx, <Ext as TranslateExt<Ext, QExt>>::Output>

The associated output type.

fn translate_ext<T, E>(&self, translator: &mut T) -> Result<Self::Output, E>

where T: ExtTranslator<Ext, QExt, E>,

Translates a struct from one generic to another where the translations for Pk are provided by the given Translator.

impl<Pk, Q, Ctx, Ext> TranslatePk<Pk, Q> for Terminal<Pk, Ctx, Ext>

where Pk: MiniscriptKey, Q: MiniscriptKey, Ctx: ScriptContext, Ext: Extension,

fn translate_pk<T, E>(&self, translate: &mut T) -> Result<Self::Output, E>

where T: Translator<Pk, Q, E>,

Converts an AST element with one public key type to one of another public key type.

type Output = Terminal<Q, Ctx, Ext>

The associated output type. This must be Self<Q>.

impl<Pk: Eq + MiniscriptKey, Ctx: Eq + ScriptContext, Ext: Eq + Extension> Eq for Terminal<Pk, Ctx, Ext>

where Pk::Sha256: Eq, Pk::Hash256: Eq, Pk::Ripemd160: Eq, Pk::Hash160: Eq,

impl<Pk: MiniscriptKey, Ctx: ScriptContext, Ext: Extension> StructuralPartialEq for Terminal<Pk, Ctx, Ext>