Enum BtcTerminal

pub enum BtcTerminal<Pk, Ctx>
where
    Pk: MiniscriptKey,
    Ctx: ScriptContext,
{
    True,
    False,
    PkK(Pk),
    PkH(Pk),
    RawPkH(Hash),
    After(AbsLockTime),
    Older(RelLockTime),
    Sha256(<Pk as MiniscriptKey>::Sha256),
    Hash256(<Pk as MiniscriptKey>::Hash256),
    Ripemd160(<Pk as MiniscriptKey>::Ripemd160),
    Hash160(<Pk as MiniscriptKey>::Hash160),
    Alt(Arc<Miniscript<Pk, Ctx>>),
    Swap(Arc<Miniscript<Pk, Ctx>>),
    Check(Arc<Miniscript<Pk, Ctx>>),
    DupIf(Arc<Miniscript<Pk, Ctx>>),
    Verify(Arc<Miniscript<Pk, Ctx>>),
    NonZero(Arc<Miniscript<Pk, Ctx>>),
    ZeroNotEqual(Arc<Miniscript<Pk, Ctx>>),
    AndV(Arc<Miniscript<Pk, Ctx>>, Arc<Miniscript<Pk, Ctx>>),
    AndB(Arc<Miniscript<Pk, Ctx>>, Arc<Miniscript<Pk, Ctx>>),
    AndOr(Arc<Miniscript<Pk, Ctx>>, Arc<Miniscript<Pk, Ctx>>, Arc<Miniscript<Pk, Ctx>>),
    OrB(Arc<Miniscript<Pk, Ctx>>, Arc<Miniscript<Pk, Ctx>>),
    OrD(Arc<Miniscript<Pk, Ctx>>, Arc<Miniscript<Pk, Ctx>>),
    OrC(Arc<Miniscript<Pk, Ctx>>, Arc<Miniscript<Pk, Ctx>>),
    OrI(Arc<Miniscript<Pk, Ctx>>, Arc<Miniscript<Pk, Ctx>>),
    Thresh(Threshold<Arc<Miniscript<Pk, Ctx>>, 0>),
    Multi(Threshold<Pk, miniscript::::miniscript::decode::Terminal::{constant#0}>),
    MultiA(Threshold<Pk, miniscript::::miniscript::decode::Terminal::{constant#1}>),
}

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(RelLockTime)

n CHECKSEQUENCEVERIFY

Sha256(<Pk as MiniscriptKey>::Sha256)

SIZE 32 EQUALVERIFY SHA256 <hash> EQUAL

Hash256(<Pk as MiniscriptKey>::Hash256)

SIZE 32 EQUALVERIFY HASH256 <hash> EQUAL

Ripemd160(<Pk as MiniscriptKey>::Ripemd160)

SIZE 32 EQUALVERIFY RIPEMD160 <hash> EQUAL

Hash160(<Pk as MiniscriptKey>::Hash160)

SIZE 32 EQUALVERIFY HASH160 <hash> EQUAL

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

TOALTSTACK [E] FROMALTSTACK

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

SWAP [E1]

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

[Kt]/[Ke] CHECKSIG

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

DUP IF [V] ENDIF

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

[T] VERIFY

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

SIZE 0NOTEQUAL IF [Fn] ENDIF

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

[X] 0NOTEQUAL

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

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

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

[E] [W] BOOLAND

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

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

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

[E] [W] BOOLOR

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

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

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

[E] NOTIF [V] ENDIF

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

IF [various] ELSE [various] ENDIF

Thresh(Threshold<Arc<Miniscript<Pk, Ctx>>, 0>)

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

Multi(Threshold<Pk, miniscript::::miniscript::decode::Terminal::{constant#0}>)

k (<key>)* n CHECKMULTISIG

MultiA(Threshold<Pk, miniscript::::miniscript::decode::Terminal::{constant#1}>)

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

Implementations

impl<Pk, Ctx> Terminal<Pk, Ctx>

where Pk: MiniscriptKey, Ctx: ScriptContext,

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

where Pk: ToPublicKey,

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<Pk, Ctx> Clone for Terminal<Pk, Ctx>

where Pk: Clone + MiniscriptKey, Ctx: Clone + ScriptContext, <Pk as MiniscriptKey>::Sha256: Clone, <Pk as MiniscriptKey>::Hash256: Clone, <Pk as MiniscriptKey>::Ripemd160: Clone, <Pk as MiniscriptKey>::Hash160: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

where Pk: MiniscriptKey, Ctx: ScriptContext,

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

Formats the value using the given formatter.

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

where Pk: MiniscriptKey, Ctx: ScriptContext,

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

Formats the value using the given formatter.

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

where Pk: FromStrKey, Ctx: ScriptContext,

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

Extract a structure from Tree representation

impl<Pk, Ctx> Hash for Terminal<Pk, Ctx>

where Pk: Hash + MiniscriptKey, Ctx: Hash + ScriptContext, <Pk as MiniscriptKey>::Sha256: Hash, <Pk as MiniscriptKey>::Hash256: Hash, <Pk as MiniscriptKey>::Ripemd160: Hash, <Pk as MiniscriptKey>::Hash160: Hash,

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

where __H: Hasher,

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> Liftable<Pk> for Terminal<Pk, Ctx>

where Pk: MiniscriptKey, Ctx: ScriptContext,

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

Converts this object into an abstract policy.

impl<Pk, Ctx> Ord for Terminal<Pk, Ctx>

where Pk: Ord + MiniscriptKey, Ctx: Ord + ScriptContext, <Pk as MiniscriptKey>::Sha256: Ord, <Pk as MiniscriptKey>::Hash256: Ord, <Pk as MiniscriptKey>::Ripemd160: Ord, <Pk as MiniscriptKey>::Hash160: Ord,

fn cmp(&self, other: &Terminal<Pk, Ctx>) -> 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, Ctx> PartialEq for Terminal<Pk, Ctx>

where Pk: PartialEq + MiniscriptKey, Ctx: PartialEq + ScriptContext, <Pk as MiniscriptKey>::Sha256: PartialEq, <Pk as MiniscriptKey>::Hash256: PartialEq, <Pk as MiniscriptKey>::Ripemd160: PartialEq, <Pk as MiniscriptKey>::Hash160: PartialEq,

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

where Pk: PartialOrd + MiniscriptKey, Ctx: PartialOrd + ScriptContext, <Pk as MiniscriptKey>::Sha256: PartialOrd, <Pk as MiniscriptKey>::Hash256: PartialOrd, <Pk as MiniscriptKey>::Ripemd160: PartialOrd, <Pk as MiniscriptKey>::Hash160: PartialOrd,

fn partial_cmp(&self, other: &Terminal<Pk, Ctx>) -> 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> Eq for Terminal<Pk, Ctx>

where Pk: Eq + MiniscriptKey, Ctx: Eq + ScriptContext, <Pk as MiniscriptKey>::Sha256: Eq, <Pk as MiniscriptKey>::Hash256: Eq, <Pk as MiniscriptKey>::Ripemd160: Eq, <Pk as MiniscriptKey>::Hash160: Eq,

impl<Pk, Ctx> StructuralPartialEq for Terminal<Pk, Ctx>

where Pk: MiniscriptKey, Ctx: ScriptContext,