Struct miniscript::miniscript::Miniscript

pub struct Miniscript<Pk: MiniscriptKey, Ctx: ScriptContext> {
    pub node: Terminal<Pk, Ctx>,
    pub ty: Type,
    pub ext: ExtData,
    // some fields omitted
}

Top-level script AST type

Fields

node: Terminal<Pk, Ctx>

A node in the Abstract Syntax Tree(

ty: Type

The correctness and malleability type information for the AST node

ext: ExtData

Additional information helpful for extra analysis.

Implementations

impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx>

pub fn requires_sig(&self) -> bool

Whether all spend paths of miniscript require a signature

pub fn is_non_malleable(&self) -> bool

Whether the miniscript is malleable

pub fn within_resource_limits(&self) -> bool

Whether the miniscript can exceed the resource limits(Opcodes, Stack limit etc)

pub fn has_mixed_timelocks(&self) -> bool

Whether the miniscript contains a combination of timelocks

pub fn has_repeated_keys(&self) -> bool

Whether the miniscript has repeated Pk or Pkh

pub fn sanity_check(&self) -> Result<(), AnalysisError>

Check whether the underlying Miniscript is safe under the current context Lifting these polices would create a semantic representation that does not represent the underlying semantics when miniscript is spent. Signing logic may not find satisfaction even if one exists.

For most cases, users should be dealing with safe scripts. Use this function to check whether the guarantees of library hold. Most functions of the library like would still work, but results cannot be relied upon

impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx>

Iterator-related extensions for Miniscript

pub fn iter(&self) -> Iter<'_, Pk, Ctx>

Creates a new Iter iterator that will iterate over all Miniscript items within AST by traversing its branches. For the specific algorithm please see Iter::next function.

pub fn iter_pk(&self) -> PkIter<'_, Pk, Ctx>

Creates a new PkIter iterator that will iterate over all plain public keys (and not key hash values) present in Miniscript items within AST by traversing all its branches. For the specific algorithm please see PkIter::next function.

pub fn iter_pkh(&self) -> PkhIter<'_, Pk, Ctx>

Creates a new PkhIter iterator that will iterate over all public keys hashes (and not plain public keys) present in Miniscript items within AST by traversing all its branches. For the specific algorithm please see PkhIter::next function.

pub fn iter_pk_pkh(&self) -> PkPkhIter<'_, Pk, Ctx>

Creates a new PkPkhIter iterator that will iterate over all plain public keys and key hash values present in Miniscript items within AST by traversing all its branches. For the specific algorithm please see PkPkhIter::next function.

pub fn branches(&self) -> Vec<&Miniscript<Pk, Ctx>>

Enumerates all child nodes of the current AST node (self) and returns a Vec referencing them.

pub fn get_nth_child(&self, n: usize) -> Option<&Miniscript<Pk, Ctx>>

Returns child node with given index, if any

pub fn get_leaf_pk(&self) -> Vec<Pk>

Returns Vec with cloned version of all public keys from the current miniscript item, if any. Otherwise returns an empty Vec.

NB: The function analyzes only single miniscript item and not any of its descendants in AST. To obtain a list of all public keys within AST use [fn.iter_pk()] function, for example miniscript.iter_pubkeys().collect().

pub fn get_leaf_pkh(&self) -> Vec<Pk::Hash>

Returns Vec with hashes of all public keys from the current miniscript item, if any. Otherwise returns an empty Vec.

For each public key the function computes hash; for each hash of the public key the function returns its cloned copy.

NB: The function analyzes only single miniscript item and not any of its descendants in AST. To obtain a list of all public key hashes within AST use [fn.iter_pkh()] function, for example miniscript.iter_pubkey_hashes().collect().

pub fn get_leaf_pk_pkh(&self) -> Vec<PkPkh<Pk>>

Returns Vec of PkPkh entries, representing either public keys or public key hashes, depending on the data from the current miniscript item. If there is no public keys or hashes, the function returns an empty Vec.

NB: The function analyzes only single miniscript item and not any of its descendants in AST. To obtain a list of all public keys or hashes within AST use [fn.iter_pk_pkh()] function, for example miniscript.iter_pubkeys_and_hashes().collect().

pub fn get_nth_pk(&self, n: usize) -> Option<Pk>

Returns Option::Some with cloned n'th public key from the current miniscript item, if any. Otherwise returns Option::None.

NB: The function analyzes only single miniscript item and not any of its descendants in AST.

pub fn get_nth_pkh(&self, n: usize) -> Option<Pk::Hash>

Returns Option::Some with hash of n'th public key from the current miniscript item, if any. Otherwise returns Option::None.

For each public key the function computes hash; for each hash of the public key the function returns it cloned copy.

NB: The function analyzes only single miniscript item and not any of its descendants in AST.

pub fn get_nth_pk_pkh(&self, n: usize) -> Option<PkPkh<Pk>>

Returns Option::Some with hash of n'th public key or hash from the current miniscript item, if any. Otherwise returns Option::None.

NB: The function analyzes only single miniscript item and not any of its descendants in AST.

impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx>

pub fn from_ast(t: Terminal<Pk, Ctx>) -> Result<Miniscript<Pk, Ctx>, Error>

Add type information(Type and Extdata) to Miniscript based on AstElem fragment. Dependent on display and clone because of Error Display code of type_check.

impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx>

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

Extracts the AstElem representing the root of the miniscript

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

Get a reference to the inner AstElem representing the root of miniscript

impl<Ctx: ScriptContext> Miniscript<PublicKey, Ctx>

pub fn parse_insane(
    script: &Script
) -> Result<Miniscript<PublicKey, Ctx>, Error>

Attempt to parse an insane(scripts don't clear sanity checks) script into a Miniscript representation. Use this to parse scripts with repeated pubkeys, timelock mixing, malleable scripts without sig or scripts that can exceed resource limits. Some of the analysis guarantees of miniscript are lost when dealing with insane scripts. In general, in a multi-party setting users should only accept sane scripts.

pub fn parse(script: &Script) -> Result<Miniscript<PublicKey, Ctx>, Error>

Attempt to parse a Script into Miniscript representation. This function will fail parsing for scripts that do not clear the [fn.analyzable.sanity_check] checks. Use [fn.parse_insane] to parse such scripts.

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

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

Encode as a Bitcoin script

pub fn script_size<ToPkCtx: Copy>(&self, to_pk_ctx: ToPkCtx) -> usize where
    Pk: ToPublicKey<ToPkCtx>, 

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.

impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx>

pub fn max_satisfaction_witness_elements(&self) -> Option<usize>

Maximum number of witness elements used to satisfy the Miniscript fragment, including the witness script itself. Used to estimate the weight of the VarInt that specifies this number in a serialized transaction.

This function may return None on malformed Miniscript objects which do not correspond to semantically sane Scripts. (Such scripts should be rejected at parse time. Any exceptions are bugs.)

pub fn max_satisfaction_size(&self) -> Option<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.

impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx>

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

This will panic if translatefpk returns an uncompressed key when converting to a Segwit descriptor. To prevent this panic, ensure translatefpk returns an error in this case instead.

pub fn from_str_insane(s: &str) -> Result<Miniscript<Pk, Ctx>, Error> where
    <Pk as FromStr>::Err: ToString,
    <<Pk as MiniscriptKey>::Hash as FromStr>::Err: ToString, 

Attempt to parse an insane(scripts don't clear sanity checks) from string into a Miniscript representation. Use this to parse scripts with repeated pubkeys, timelock mixing, malleable scripts without sig or scripts that can exceed resource limits. Some of the analysis guarantees of miniscript are lost when dealing with insane scripts. In general, in a multi-party setting users should only accept sane scripts.

impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx>

pub fn satisfy<ToPkCtx: Copy, S: Satisfier<ToPkCtx, Pk>>(
    &self,
    satisfier: S,
    to_pk_ctx: ToPkCtx
) -> Result<Vec<Vec<u8>>, Error> where
    Pk: ToPublicKey<ToPkCtx>, 

Attempt to produce non-malleable satisfying witness for the witness script represented by the parse tree

pub fn satisfy_malleable<ToPkCtx: Copy, S: Satisfier<ToPkCtx, Pk>>(
    &self,
    satisfier: S,
    to_pk_ctx: ToPkCtx
) -> Result<Vec<Vec<u8>>, Error> where
    Pk: ToPublicKey<ToPkCtx>, 

Attempt to produce a malleable satisfying witness for the witness script represented by the parse tree

Trait Implementations

impl<Pk: Clone + MiniscriptKey, Ctx: Clone + ScriptContext> Clone for Miniscript<Pk, Ctx>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Pk: MiniscriptKey, Ctx: ScriptContext> Debug for Miniscript<Pk, Ctx>

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

Formats the value using the given formatter.

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

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

Formats the value using the given formatter.

impl<Pk: MiniscriptKey, Ctx: ScriptContext> Eq for Miniscript<Pk, Ctx>

Eq of Miniscript must depend only on node and not the type information. The type information and extra_properties can be deterministically determined by the ast.

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

type Err = Error

The associated error which can be returned from parsing.

pub fn from_str(s: &str) -> Result<Miniscript<Pk, Ctx>, Error>

Parse a Miniscript from string and perform sanity checks See [fn.from_str_insane] to parse scripts from string that do not clear the [fn.analyzable.sanity_check] checks.

impl<Pk, Ctx> FromTree for Miniscript<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<Miniscript<Pk, Ctx>, Error>

Parse an expression tree into a Miniscript. As a general rule, this should not be called directly; rather go through the descriptor API.

impl<Pk: Hash + MiniscriptKey, Ctx: Hash + ScriptContext> Hash for Miniscript<Pk, Ctx>

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

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

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

Convert the object into an abstract policy

impl<Pk: MiniscriptKey, Ctx: ScriptContext> Ord for Miniscript<Pk, Ctx>

Ord of Miniscript must depend only on node and not the type information. The type information and extra_properties can be deterministically determined by the ast.

pub fn cmp(&self, other: &Miniscript<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: MiniscriptKey, Ctx: ScriptContext> PartialEq<Miniscript<Pk, Ctx>> for Miniscript<Pk, Ctx>

PartialEq of Miniscript must depend only on node and not the type information. The type information and extra_properties can be deterministically determined by the ast.

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

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

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<Pk: MiniscriptKey, Ctx: ScriptContext> PartialOrd<Miniscript<Pk, Ctx>> for Miniscript<Pk, Ctx>

PartialOrd of Miniscript must depend only on node and not the type information. The type information and extra_properties can be deterministically determined by the ast.

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

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

#[must_use]pub fn lt(&self, other: &Rhs) -> bool

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

#[must_use]pub fn le(&self, other: &Rhs) -> bool

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

#[must_use]pub fn gt(&self, other: &Rhs) -> bool

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

#[must_use]pub fn ge(&self, other: &Rhs) -> bool

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