Enum bdk::descriptor::Terminal

pub enum Terminal<Pk, Ctx> where
    Pk: MiniscriptKey,
    Ctx: ScriptContext,  {
    True,
    False,
    PkK(Pk),
    PkH(<Pk as MiniscriptKey>::Hash),
    After(u32),
    Older(u32),
    Sha256(Hash),
    Hash256(Hash),
    Ripemd160(Hash),
    Hash160(Hash),
    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(usize, Vec<Arc<Miniscript<Pk, Ctx>>, Global>),
    Multi(usize, Vec<Pk, Global>),
}

All AST elements

Variants

True

1

False

0

PkK(Pk)

<key>

PkH(<Pk as MiniscriptKey>::Hash)

DUP HASH160 <keyhash> EQUALVERIFY

After(u32)

n CHECKLOCKTIMEVERIFY

Older(u32)

n CHECKSEQUENCEVERIFY

Sha256(Hash)

SIZE 32 EQUALVERIFY SHA256 <hash> EQUAL

Hash256(Hash)

SIZE 32 EQUALVERIFY HASH256 <hash> EQUAL

Ripemd160(Hash)

SIZE 32 EQUALVERIFY RIPEMD160 <hash> EQUAL

Hash160(Hash)

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(usize, Vec<Arc<Miniscript<Pk, Ctx>>, Global>)

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

Multi(usize, Vec<Pk, Global>)

k ()* n CHECKMULTISIG

Implementations

impl<Pk, Ctx> Terminal<Pk, Ctx> where
    Pk: MiniscriptKey,
    Ctx: ScriptContext, 

pub fn translate_pk<FPk, FPkh, Q, Error>(
    &self,
    translatefpk: &mut FPk,
    translatefpkh: &mut FPkh
) -> Result<Terminal<Q, Ctx>, Error> where
    Q: MiniscriptKey,
    FPk: FnMut(&Pk) -> Result<Q, Error>,
    FPkh: FnMut(&<Pk as MiniscriptKey>::Hash) -> Result<<Q as MiniscriptKey>::Hash, Error>, 

Convert an AST element with one public key type to one of another public key type .This will panic while converting to Segwit Miniscript using uncompressed public keys

impl<Pk, Ctx> Terminal<Pk, Ctx> where
    Pk: MiniscriptKey,
    Ctx: ScriptContext, 

pub fn encode<ToPkCtx>(&self, builder: Builder, to_pk_ctx: ToPkCtx) -> Builder where
    Pk: ToPublicKey<ToPkCtx>,
    ToPkCtx: Copy, 

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<ToPkCtx>(&self, to_pk_ctx: ToPkCtx) -> usize where
    Pk: ToPublicKey<ToPkCtx>,
    ToPkCtx: Copy, 

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, Ctx> Clone for Terminal<Pk, Ctx> where
    Pk: MiniscriptKey + Clone,
    Ctx: ScriptContext + Clone,
    <Pk as MiniscriptKey>::Hash: Clone, 

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

Returns a copy of the value.

pub 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, 

pub 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, 

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

Formats the value using the given formatter.

impl<Pk, Ctx> Eq for Terminal<Pk, Ctx> where
    Pk: MiniscriptKey + Eq,
    Ctx: ScriptContext + Eq,
    <Pk as MiniscriptKey>::Hash: Eq, 

impl<Pk, Ctx> FromTree for Terminal<Pk, Ctx> where
    Pk: MiniscriptKey,
    Ctx: ScriptContext,
    <Pk as FromStr>::Err: ToString,
    <<Pk as MiniscriptKey>::Hash as FromStr>::Err: ToString, 

pub 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: MiniscriptKey + Hash,
    Ctx: ScriptContext + Hash,
    <Pk as MiniscriptKey>::Hash: Hash, 

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<Pk, Ctx> Liftable<Pk> for Terminal<Pk, Ctx> where
    Pk: MiniscriptKey,
    Ctx: ScriptContext, 

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

Convert the object into an abstract policy

impl<Pk, Ctx> Ord for Terminal<Pk, Ctx> where
    Pk: MiniscriptKey + Ord,
    Ctx: ScriptContext + Ord,
    <Pk as MiniscriptKey>::Hash: Ord, 

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

This method returns an Ordering between self and other.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<Pk, Ctx> PartialEq<Terminal<Pk, Ctx>> for Terminal<Pk, Ctx> where
    Pk: MiniscriptKey + PartialEq<Pk>,
    Ctx: ScriptContext + PartialEq<Ctx>,
    <Pk as MiniscriptKey>::Hash: PartialEq<<Pk as MiniscriptKey>::Hash>, 

pub fn eq(&self, other: &Terminal<Pk, Ctx>) -> bool

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

pub fn ne(&self, other: &Terminal<Pk, Ctx>) -> bool

This method tests for !=.

impl<Pk, Ctx> PartialOrd<Terminal<Pk, Ctx>> for Terminal<Pk, Ctx> where
    Pk: MiniscriptKey + PartialOrd<Pk>,
    Ctx: ScriptContext + PartialOrd<Ctx>,
    <Pk as MiniscriptKey>::Hash: PartialOrd<<Pk as MiniscriptKey>::Hash>, 

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

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

pub fn lt(&self, other: &Terminal<Pk, Ctx>) -> bool

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

pub fn le(&self, other: &Terminal<Pk, Ctx>) -> bool

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

pub fn gt(&self, other: &Terminal<Pk, Ctx>) -> bool

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

pub fn ge(&self, other: &Terminal<Pk, Ctx>) -> bool

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

impl<Pk, Ctx> StructuralEq for Terminal<Pk, Ctx> where
    Pk: MiniscriptKey,
    Ctx: ScriptContext, 

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