Enum bdk::descriptor::Terminal

pub enum Terminal<Pk, Ctx> where
    Ctx: ScriptContext,
    Pk: MiniscriptKey,  {
    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>>>),
    Multi(usize, Vec<Pk>),
}

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

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

Multi(usize, Vec<Pk>)

k ()* n CHECKMULTISIG

Implementations

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

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

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
    Ctx: ScriptContext,
    Pk: MiniscriptKey + ToPublicKey, 

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) -> Option<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 the fragment is not an E, W or Ke.

pub fn max_dissatisfaction_size(&self, one_cost: usize) -> Option<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 the fragment is not E, W or Ke

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

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

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

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

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

Feeds a slice of this type into the given [Hasher].

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

fn lift(&self) -> Policy<Pk>

Convert the object into an abstract policy

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

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

This method returns an [Ordering] between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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

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

Restrict a value to a certain interval.

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

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

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

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

This method tests for !=.

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

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: &Terminal<Pk, Ctx>) -> bool

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

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.

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

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

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
    Ctx: ScriptContext,
    Pk: MiniscriptKey, 

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