Enum miniscript::miniscript::decode::Terminal

pub enum Terminal<Pk: MiniscriptKey, Ctx: ScriptContext> {
    True,
    False,
    PkK(Pk),
    PkH(Pk::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::Hash)

DUP HASH160 <keyhash> EQUALVERIFY

After(u32)

n CHECKSEQUENCEVERIFY

Older(u32)

n CHECKLOCKTIMEVERIFY

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

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::Hash) -> Result<Q::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: MiniscriptKey + ToPublicKey, Ctx: ScriptContext> Terminal<Pk, Ctx>

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

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

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, 

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

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

Feeds a slice of this type into the given Hasher.

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

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

Convert the object into an abstract policy

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

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

Restrict a value to a certain interval.

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

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

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

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

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

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

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

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

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

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

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

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