Struct miniscript::miniscript::Miniscript
source · pub struct Miniscript<Pk: MiniscriptKey, Ctx: ScriptContext> {
pub node: Terminal<Pk, Ctx>,
pub ty: Type,
pub ext: ExtData,
/* private fields */
}
Expand description
The top-level miniscript abstract syntax tree (AST).
Fields§
§node: Terminal<Pk, Ctx>
A node in the AST.
ty: Type
The correctness and malleability type information for the AST node.
ext: ExtData
Additional information helpful for extra analysis.
Implementations§
source§impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx>
impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx>
sourcepub fn requires_sig(&self) -> bool
pub fn requires_sig(&self) -> bool
Whether all spend paths of miniscript require a signature
sourcepub fn is_non_malleable(&self) -> bool
pub fn is_non_malleable(&self) -> bool
Whether the miniscript is malleable
sourcepub fn within_resource_limits(&self) -> bool
pub fn within_resource_limits(&self) -> bool
Whether the miniscript can exceed the resource limits(Opcodes, Stack limit etc)
sourcepub fn has_mixed_timelocks(&self) -> bool
pub fn has_mixed_timelocks(&self) -> bool
Whether the miniscript contains a combination of timelocks
sourcepub fn has_repeated_keys(&self) -> bool
pub fn has_repeated_keys(&self) -> bool
Whether the miniscript has repeated Pk or Pkh
sourcepub fn contains_raw_pkh(&self) -> bool
pub fn contains_raw_pkh(&self) -> bool
Whether the given miniscript contains a raw pkh fragment
sourcepub fn sanity_check(&self) -> Result<(), AnalysisError>
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
source§impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx>
impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx>
Iterator-related extensions for Miniscript
sourcepub fn iter(&self) -> Iter<'_, Pk, Ctx> ⓘ
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.
sourcepub fn iter_pk(&self) -> PkIter<'_, Pk, Ctx> ⓘ
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.
sourcepub fn branches(&self) -> Vec<&Miniscript<Pk, Ctx>>
pub fn branches(&self) -> Vec<&Miniscript<Pk, Ctx>>
Enumerates all child nodes of the current AST node (self
) and returns a Vec
referencing
them.
sourcepub fn get_nth_child(&self, n: usize) -> Option<&Miniscript<Pk, Ctx>>
pub fn get_nth_child(&self, n: usize) -> Option<&Miniscript<Pk, Ctx>>
Returns child node with given index, if any
sourcepub fn get_nth_pk(&self, n: usize) -> Option<Pk>
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.
source§impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx>
impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx>
sourcepub fn from_ast(t: Terminal<Pk, Ctx>) -> Result<Miniscript<Pk, Ctx>, Error>
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.
sourcepub fn from_components_unchecked(
node: Terminal<Pk, Ctx>,
ty: Type,
ext: ExtData,
) -> Miniscript<Pk, Ctx>
pub fn from_components_unchecked( node: Terminal<Pk, Ctx>, ty: Type, ext: ExtData, ) -> Miniscript<Pk, Ctx>
Create a new Miniscript
from a Terminal
node and a Type
annotation
This does not check the typing rules. The user is responsible for ensuring
that the type provided is correct.
You should almost always use Miniscript::from_ast
instead of this function.
source§impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx>
impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx>
sourcepub fn into_inner(self) -> Terminal<Pk, Ctx>
pub fn into_inner(self) -> Terminal<Pk, Ctx>
Extracts the AstElem
representing the root of the miniscript
sourcepub fn as_inner(&self) -> &Terminal<Pk, Ctx>
pub fn as_inner(&self) -> &Terminal<Pk, Ctx>
Get a reference to the inner AstElem
representing the root of miniscript
sourcepub fn encode(&self) -> ScriptBufwhere
Pk: ToPublicKey,
pub fn encode(&self) -> ScriptBufwhere
Pk: ToPublicKey,
Encode as a Bitcoin script
sourcepub fn script_size(&self) -> usize
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.
sourcepub fn max_satisfaction_witness_elements(&self) -> Result<usize, Error>
pub fn max_satisfaction_witness_elements(&self) -> Result<usize, Error>
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 returns Error when the Miniscript is impossible to satisfy
sourcepub fn max_satisfaction_size(&self) -> Result<usize, Error>
pub fn max_satisfaction_size(&self) -> Result<usize, Error>
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.
sourcepub fn satisfy<S: Satisfier<Pk>>(
&self,
satisfier: S,
) -> Result<Vec<Vec<u8>>, Error>where
Pk: ToPublicKey,
pub fn satisfy<S: Satisfier<Pk>>(
&self,
satisfier: S,
) -> Result<Vec<Vec<u8>>, Error>where
Pk: ToPublicKey,
Attempt to produce non-malleable satisfying witness for the witness script represented by the parse tree
sourcepub fn satisfy_malleable<S: Satisfier<Pk>>(
&self,
satisfier: S,
) -> Result<Vec<Vec<u8>>, Error>where
Pk: ToPublicKey,
pub fn satisfy_malleable<S: Satisfier<Pk>>(
&self,
satisfier: S,
) -> Result<Vec<Vec<u8>>, Error>where
Pk: ToPublicKey,
Attempt to produce a malleable satisfying witness for the witness script represented by the parse tree
sourcepub fn build_template<P: AssetProvider<Pk>>(
&self,
provider: &P,
) -> Satisfaction<Placeholder<Pk>>where
Pk: ToPublicKey,
pub fn build_template<P: AssetProvider<Pk>>(
&self,
provider: &P,
) -> Satisfaction<Placeholder<Pk>>where
Pk: ToPublicKey,
Attempt to produce a non-malleable witness template given the assets available
sourcepub fn build_template_mall<P: AssetProvider<Pk>>(
&self,
provider: &P,
) -> Satisfaction<Placeholder<Pk>>where
Pk: ToPublicKey,
pub fn build_template_mall<P: AssetProvider<Pk>>(
&self,
provider: &P,
) -> Satisfaction<Placeholder<Pk>>where
Pk: ToPublicKey,
Attempt to produce a malleable witness template given the assets available
source§impl<Ctx: ScriptContext> Miniscript<Ctx::Key, Ctx>
impl<Ctx: ScriptContext> Miniscript<Ctx::Key, Ctx>
sourcepub fn parse_insane(script: &Script) -> Result<Miniscript<Ctx::Key, Ctx>, Error>
pub fn parse_insane(script: &Script) -> Result<Miniscript<Ctx::Key, 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.
sourcepub fn parse_with_ext(
script: &Script,
ext: &ExtParams,
) -> Result<Miniscript<Ctx::Key, Ctx>, Error>
pub fn parse_with_ext( script: &Script, ext: &ExtParams, ) -> Result<Miniscript<Ctx::Key, Ctx>, Error>
Attempt to parse an miniscript with extra features that not yet specified in the spec. Users should not use this function unless they scripts can/will change in the future. Currently, this function supports the following features: - Parsing all insane scripts - Parsing miniscripts with raw pubkey hashes
Allowed extra features can be specified by the ext ExtParams
argument.
sourcepub fn parse(script: &Script) -> Result<Miniscript<Ctx::Key, Ctx>, Error>
pub fn parse(script: &Script) -> Result<Miniscript<Ctx::Key, Ctx>, Error>
Attempt to parse a Script into Miniscript representation.
This function will fail parsing for scripts that do not clear the
Miniscript::sanity_check
checks. Use Miniscript::parse_insane
to
parse such scripts.
§Decode/Parse a miniscript from script hex
use miniscript::{Miniscript, Segwitv0, Tap};
use miniscript::bitcoin::secp256k1::XOnlyPublicKey;
use miniscript::bitcoin::hashes::hex::FromHex;
type Segwitv0Script = Miniscript<bitcoin::PublicKey, Segwitv0>;
type TapScript = Miniscript<XOnlyPublicKey, Tap>;
// parse x-only miniscript in Taproot context
let tapscript_ms = TapScript::parse(&bitcoin::ScriptBuf::from_hex(
"202788ee41e76f4f3af603da5bc8fa22997bc0344bb0f95666ba6aaff0242baa99ac",
).expect("Even length hex"))
.expect("Xonly keys are valid only in taproot context");
// tapscript fails decoding when we use them with compressed keys
let err = TapScript::parse(&bitcoin::ScriptBuf::from_hex(
"21022788ee41e76f4f3af603da5bc8fa22997bc0344bb0f95666ba6aaff0242baa99ac",
).expect("Even length hex"))
.expect_err("Compressed keys cannot be used in Taproot context");
// Segwitv0 succeeds decoding with full keys.
Segwitv0Script::parse(&bitcoin::ScriptBuf::from_hex(
"21022788ee41e76f4f3af603da5bc8fa22997bc0344bb0f95666ba6aaff0242baa99ac",
).expect("Even length hex"))
.expect("Compressed keys are allowed in Segwit context");
source§impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx>
impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx>
sourcepub fn substitute_raw_pkh(
&self,
pk_map: &BTreeMap<Hash, Pk>,
) -> Miniscript<Pk, Ctx>
pub fn substitute_raw_pkh( &self, pk_map: &BTreeMap<Hash, Pk>, ) -> Miniscript<Pk, Ctx>
Substitutes raw public keys hashes with the public keys as provided by map.
source§impl<Pk: FromStrKey, Ctx: ScriptContext> Miniscript<Pk, Ctx>
impl<Pk: FromStrKey, Ctx: ScriptContext> Miniscript<Pk, Ctx>
sourcepub fn from_str_insane(s: &str) -> Result<Miniscript<Pk, Ctx>, Error>
pub fn from_str_insane(s: &str) -> Result<Miniscript<Pk, Ctx>, Error>
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.
sourcepub fn from_str_ext(
s: &str,
ext: &ExtParams,
) -> Result<Miniscript<Pk, Ctx>, Error>
pub fn from_str_ext( s: &str, ext: &ExtParams, ) -> Result<Miniscript<Pk, Ctx>, Error>
Attempt to parse an Miniscripts that don’t follow the spec. Use this to parse scripts with repeated pubkeys, timelock mixing, malleable scripts, raw pubkey hashes without sig or scripts that can exceed resource limits.
Use ExtParams
builder to specify the types of non-sane rules to allow while parsing.
source§impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx>
impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx>
sourcepub fn lift_check(&self) -> Result<(), LiftError>
pub fn lift_check(&self) -> Result<(), LiftError>
Lifting corresponds to conversion of a miniscript into a Semantic
policy for human readable or machine analysis. However, naively lifting
miniscripts can result in incorrect interpretations that don’t
correspond to the underlying semantics when we try to spend them on
bitcoin network. This can occur if the miniscript contains:
- A combination of timelocks
- A spend that exceeds resource limits
Trait Implementations§
source§impl<Pk: Clone + MiniscriptKey, Ctx: Clone + ScriptContext> Clone for Miniscript<Pk, Ctx>
impl<Pk: Clone + MiniscriptKey, Ctx: Clone + ScriptContext> Clone for Miniscript<Pk, Ctx>
source§fn clone(&self) -> Miniscript<Pk, Ctx>
fn clone(&self) -> Miniscript<Pk, Ctx>
1.0.0 · source§fn clone_from(&mut self, source: &Self)
fn clone_from(&mut self, source: &Self)
source
. Read moresource§impl<Pk: MiniscriptKey, Ctx: ScriptContext> Debug for Miniscript<Pk, Ctx>
impl<Pk: MiniscriptKey, Ctx: ScriptContext> Debug for Miniscript<Pk, Ctx>
source§impl<Pk: MiniscriptKey, Ctx: ScriptContext> Display for Miniscript<Pk, Ctx>
impl<Pk: MiniscriptKey, Ctx: ScriptContext> Display for Miniscript<Pk, Ctx>
source§impl<Pk: MiniscriptKey, Ctx: ScriptContext> ForEachKey<Pk> for Miniscript<Pk, Ctx>
impl<Pk: MiniscriptKey, Ctx: ScriptContext> ForEachKey<Pk> for Miniscript<Pk, Ctx>
source§impl<Pk: FromStrKey, Ctx: ScriptContext> FromStr for Miniscript<Pk, Ctx>
impl<Pk: FromStrKey, Ctx: ScriptContext> FromStr for Miniscript<Pk, Ctx>
source§fn from_str(s: &str) -> Result<Miniscript<Pk, Ctx>, Error>
fn from_str(s: &str) -> Result<Miniscript<Pk, Ctx>, Error>
Parse a Miniscript from string and perform sanity checks See Miniscript::from_str_insane to parse scripts from string that do not clear the Miniscript::sanity_check checks.
source§impl<Pk: FromStrKey, Ctx: ScriptContext> FromTree for Miniscript<Pk, Ctx>
impl<Pk: FromStrKey, Ctx: ScriptContext> FromTree for Miniscript<Pk, Ctx>
source§impl<Pk: MiniscriptKey, Ctx: ScriptContext> Hash for Miniscript<Pk, Ctx>
impl<Pk: MiniscriptKey, Ctx: ScriptContext> Hash for Miniscript<Pk, Ctx>
Hash
of Miniscript
must depend only on node and not the type information.
The type information and extra properties are implied by the AST.
source§impl<Pk: MiniscriptKey, Ctx: ScriptContext> Liftable<Pk> for Miniscript<Pk, Ctx>
impl<Pk: MiniscriptKey, Ctx: ScriptContext> Liftable<Pk> for Miniscript<Pk, Ctx>
source§impl<Pk: MiniscriptKey, Ctx: ScriptContext> Ord for Miniscript<Pk, Ctx>
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 are implied by the AST.
source§fn cmp(&self, other: &Miniscript<Pk, Ctx>) -> Ordering
fn cmp(&self, other: &Miniscript<Pk, Ctx>) -> Ordering
1.21.0 · source§fn max(self, other: Self) -> Selfwhere
Self: Sized,
fn max(self, other: Self) -> Selfwhere
Self: Sized,
source§impl<Pk: MiniscriptKey, Ctx: ScriptContext> PartialEq for Miniscript<Pk, Ctx>
impl<Pk: MiniscriptKey, Ctx: ScriptContext> PartialEq for Miniscript<Pk, Ctx>
PartialEq
of Miniscript
must depend only on node and not the type information.
The type information and extra properties are implied by the AST.
source§impl<Pk: MiniscriptKey, Ctx: ScriptContext> PartialOrd for Miniscript<Pk, Ctx>
impl<Pk: MiniscriptKey, Ctx: ScriptContext> PartialOrd for Miniscript<Pk, Ctx>
PartialOrd
of Miniscript
must depend only on node and not the type information.
The type information and extra properties are implied by the AST.
source§impl<Pk, Q, Ctx> TranslatePk<Pk, Q> for Miniscript<Pk, Ctx>
impl<Pk, Q, Ctx> TranslatePk<Pk, Q> for Miniscript<Pk, Ctx>
source§fn translate_pk<T, E>(&self, t: &mut T) -> Result<Self::Output, TranslateErr<E>>where
T: Translator<Pk, Q, E>,
fn translate_pk<T, E>(&self, t: &mut T) -> Result<Self::Output, TranslateErr<E>>where
T: Translator<Pk, Q, E>,
Translates a struct from one generic to another where the translation
for Pk is provided by Translator
§type Output = Miniscript<Q, Ctx>
type Output = Miniscript<Q, Ctx>
Self<Q>
.source§impl<'a, Pk: MiniscriptKey, Ctx: ScriptContext> TreeLike for &'a Miniscript<Pk, Ctx>
impl<'a, Pk: MiniscriptKey, Ctx: ScriptContext> TreeLike for &'a Miniscript<Pk, Ctx>
source§fn n_children(&self) -> usize
fn n_children(&self) -> usize
source§fn nth_child(&self, n: usize) -> Option<Self>
fn nth_child(&self, n: usize) -> Option<Self>
source§fn pre_order_iter(self) -> PreOrderIter<Self> ⓘ
fn pre_order_iter(self) -> PreOrderIter<Self> ⓘ
source§fn verbose_pre_order_iter(self) -> VerbosePreOrderIter<Self> ⓘ
fn verbose_pre_order_iter(self) -> VerbosePreOrderIter<Self> ⓘ
source§fn post_order_iter(self) -> PostOrderIter<Self> ⓘ
fn post_order_iter(self) -> PostOrderIter<Self> ⓘ
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 are implied by the AST.
Auto Trait Implementations§
impl<Pk, Ctx> Freeze for Miniscript<Pk, Ctx>where
Pk: Freeze,
<Pk as MiniscriptKey>::Sha256: Freeze,
<Pk as MiniscriptKey>::Hash256: Freeze,
<Pk as MiniscriptKey>::Ripemd160: Freeze,
<Pk as MiniscriptKey>::Hash160: Freeze,
impl<Pk, Ctx> RefUnwindSafe for Miniscript<Pk, Ctx>where
Pk: RefUnwindSafe,
<Pk as MiniscriptKey>::Sha256: RefUnwindSafe,
<Pk as MiniscriptKey>::Hash256: RefUnwindSafe,
<Pk as MiniscriptKey>::Ripemd160: RefUnwindSafe,
<Pk as MiniscriptKey>::Hash160: RefUnwindSafe,
Ctx: RefUnwindSafe,
impl<Pk, Ctx> Send for Miniscript<Pk, Ctx>where
Pk: Send + Sync,
<Pk as MiniscriptKey>::Sha256: Send + Sync,
<Pk as MiniscriptKey>::Hash256: Send + Sync,
<Pk as MiniscriptKey>::Ripemd160: Send + Sync,
<Pk as MiniscriptKey>::Hash160: Send + Sync,
Ctx: Send + Sync,
impl<Pk, Ctx> Sync for Miniscript<Pk, Ctx>where
Pk: Sync + Send,
<Pk as MiniscriptKey>::Sha256: Sync + Send,
<Pk as MiniscriptKey>::Hash256: Sync + Send,
<Pk as MiniscriptKey>::Ripemd160: Sync + Send,
<Pk as MiniscriptKey>::Hash160: Sync + Send,
Ctx: Sync + Send,
impl<Pk, Ctx> Unpin for Miniscript<Pk, Ctx>where
Pk: Unpin,
<Pk as MiniscriptKey>::Sha256: Unpin,
<Pk as MiniscriptKey>::Hash256: Unpin,
<Pk as MiniscriptKey>::Ripemd160: Unpin,
<Pk as MiniscriptKey>::Hash160: Unpin,
Ctx: Unpin,
impl<Pk, Ctx> UnwindSafe for Miniscript<Pk, Ctx>where
Pk: UnwindSafe + RefUnwindSafe,
<Pk as MiniscriptKey>::Sha256: UnwindSafe + RefUnwindSafe,
<Pk as MiniscriptKey>::Hash256: UnwindSafe + RefUnwindSafe,
<Pk as MiniscriptKey>::Ripemd160: UnwindSafe + RefUnwindSafe,
<Pk as MiniscriptKey>::Hash160: UnwindSafe + RefUnwindSafe,
Ctx: UnwindSafe + RefUnwindSafe,
Blanket Implementations§
source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
source§impl<T> CloneToUninit for Twhere
T: Clone,
impl<T> CloneToUninit for Twhere
T: Clone,
source§default unsafe fn clone_to_uninit(&self, dst: *mut T)
default unsafe fn clone_to_uninit(&self, dst: *mut T)
clone_to_uninit
)