[−][src]Enum miniscript::miniscript::decode::Terminal
All AST elements
Variants
1
0
<key>
PkH(Pk::Hash)
DUP HASH160 <keyhash> EQUALVERIFY
After(u32)
n CHECKLOCKTIMEVERIFY
Older(u32)
n CHECKSEQUENCEVERIFY
SIZE 32 EQUALVERIFY SHA256 <hash> EQUAL
SIZE 32 EQUALVERIFY HASH256 <hash> EQUAL
SIZE 32 EQUALVERIFY RIPEMD160 <hash> EQUAL
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
k (
Implementations
impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx>
[src]
pub fn encode(&self, mut builder: Builder) -> Builder where
Pk: ToPublicKey,
[src]
Pk: ToPublicKey,
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
[src]
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: Clone + MiniscriptKey, Ctx: Clone + ScriptContext> Clone for Terminal<Pk, Ctx> where
Pk::Hash: Clone,
[src]
Pk::Hash: Clone,
impl<Pk: MiniscriptKey, Ctx: ScriptContext> Debug for Terminal<Pk, Ctx>
[src]
impl<Pk: MiniscriptKey, Ctx: ScriptContext> Display for Terminal<Pk, Ctx>
[src]
impl<Pk: Eq + MiniscriptKey, Ctx: Eq + ScriptContext> Eq for Terminal<Pk, Ctx> where
Pk::Hash: Eq,
[src]
Pk::Hash: Eq,
impl<Pk: MiniscriptKey, Ctx: ScriptContext> ForEachKey<Pk> for Terminal<Pk, Ctx>
[src]
pub fn for_each_key<'a, F: FnMut(ForEach<'a, Pk>) -> bool>(
&'a self,
mut pred: F
) -> bool where
Pk: 'a,
Pk::Hash: 'a,
[src]
&'a self,
mut pred: F
) -> bool where
Pk: 'a,
Pk::Hash: 'a,
pub fn for_any_key<'a, F: FnMut(ForEach<'a, Pk>) -> bool>(
&'a self,
mut pred: F
) -> bool where
Pk: 'a,
Pk::Hash: 'a,
[src]
&'a self,
mut pred: F
) -> bool where
Pk: 'a,
Pk::Hash: 'a,
impl<Pk, Ctx> FromTree for Terminal<Pk, Ctx> where
Pk: MiniscriptKey + FromStr,
Pk::Hash: FromStr,
Ctx: ScriptContext,
<Pk as FromStr>::Err: ToString,
<<Pk as MiniscriptKey>::Hash as FromStr>::Err: ToString,
[src]
Pk: MiniscriptKey + FromStr,
Pk::Hash: FromStr,
Ctx: ScriptContext,
<Pk as FromStr>::Err: ToString,
<<Pk as MiniscriptKey>::Hash as FromStr>::Err: ToString,
impl<Pk: Hash + MiniscriptKey, Ctx: Hash + ScriptContext> Hash for Terminal<Pk, Ctx> where
Pk::Hash: Hash,
[src]
Pk::Hash: Hash,
pub fn hash<__H: Hasher>(&self, state: &mut __H)
[src]
pub fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher,
1.3.0[src]
H: Hasher,
impl<Pk: MiniscriptKey, Ctx: ScriptContext> Liftable<Pk> for Terminal<Pk, Ctx>
[src]
impl<Pk: Ord + MiniscriptKey, Ctx: Ord + ScriptContext> Ord for Terminal<Pk, Ctx> where
Pk::Hash: Ord,
[src]
Pk::Hash: Ord,
pub fn cmp(&self, other: &Terminal<Pk, Ctx>) -> Ordering
[src]
#[must_use]pub fn max(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn min(self, other: Self) -> Self
1.21.0[src]
#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self
1.50.0[src]
impl<Pk: PartialEq + MiniscriptKey, Ctx: PartialEq + ScriptContext> PartialEq<Terminal<Pk, Ctx>> for Terminal<Pk, Ctx> where
Pk::Hash: PartialEq,
[src]
Pk::Hash: PartialEq,
pub fn eq(&self, other: &Terminal<Pk, Ctx>) -> bool
[src]
pub fn ne(&self, other: &Terminal<Pk, Ctx>) -> bool
[src]
impl<Pk: PartialOrd + MiniscriptKey, Ctx: PartialOrd + ScriptContext> PartialOrd<Terminal<Pk, Ctx>> for Terminal<Pk, Ctx> where
Pk::Hash: PartialOrd,
[src]
Pk::Hash: PartialOrd,
pub fn partial_cmp(&self, other: &Terminal<Pk, Ctx>) -> Option<Ordering>
[src]
pub fn lt(&self, other: &Terminal<Pk, Ctx>) -> bool
[src]
pub fn le(&self, other: &Terminal<Pk, Ctx>) -> bool
[src]
pub fn gt(&self, other: &Terminal<Pk, Ctx>) -> bool
[src]
pub fn ge(&self, other: &Terminal<Pk, Ctx>) -> bool
[src]
impl<Pk: MiniscriptKey, Ctx: ScriptContext> StructuralEq for Terminal<Pk, Ctx>
[src]
impl<Pk: MiniscriptKey, Ctx: ScriptContext> StructuralPartialEq for Terminal<Pk, Ctx>
[src]
impl<Pk: MiniscriptKey, Q: MiniscriptKey, Ctx: ScriptContext> TranslatePk<Pk, Q> for Terminal<Pk, Ctx>
[src]
type Output = Terminal<Q, Ctx>
The associated output type. This must be Self
pub fn translate_pk<FPk, FPkh, FuncError>(
&self,
mut translatefpk: FPk,
mut translatefpkh: FPkh
) -> Result<Self::Output, FuncError> where
FPk: FnMut(&Pk) -> Result<Q, FuncError>,
FPkh: FnMut(&Pk::Hash) -> Result<Q::Hash, FuncError>,
[src]
&self,
mut translatefpk: FPk,
mut translatefpkh: FPkh
) -> Result<Self::Output, FuncError> where
FPk: FnMut(&Pk) -> Result<Q, FuncError>,
FPkh: FnMut(&Pk::Hash) -> Result<Q::Hash, FuncError>,
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
pub fn translate_pk_infallible<Fpk, Fpkh>(
&self,
mut translatefpk: Fpk,
mut translatefpkh: Fpkh
) -> Self::Output where
Fpk: FnMut(&P) -> Q,
Fpkh: FnMut(&P::Hash) -> Q::Hash,
[src]
&self,
mut translatefpk: Fpk,
mut translatefpkh: Fpkh
) -> Self::Output where
Fpk: FnMut(&P) -> Q,
Fpkh: FnMut(&P::Hash) -> Q::Hash,
Auto Trait Implementations
impl<Pk, Ctx> RefUnwindSafe for Terminal<Pk, Ctx> where
Ctx: RefUnwindSafe,
Pk: RefUnwindSafe,
<Pk as MiniscriptKey>::Hash: RefUnwindSafe,
[src]
Ctx: RefUnwindSafe,
Pk: RefUnwindSafe,
<Pk as MiniscriptKey>::Hash: RefUnwindSafe,
impl<Pk, Ctx> Send for Terminal<Pk, Ctx> where
Ctx: Send + Sync,
Pk: Send + Sync,
<Pk as MiniscriptKey>::Hash: Send + Sync,
[src]
Ctx: Send + Sync,
Pk: Send + Sync,
<Pk as MiniscriptKey>::Hash: Send + Sync,
impl<Pk, Ctx> Sync for Terminal<Pk, Ctx> where
Ctx: Send + Sync,
Pk: Send + Sync,
<Pk as MiniscriptKey>::Hash: Send + Sync,
[src]
Ctx: Send + Sync,
Pk: Send + Sync,
<Pk as MiniscriptKey>::Hash: Send + Sync,
impl<Pk, Ctx> Unpin for Terminal<Pk, Ctx> where
Pk: Unpin,
<Pk as MiniscriptKey>::Hash: Unpin,
[src]
Pk: Unpin,
<Pk as MiniscriptKey>::Hash: Unpin,
impl<Pk, Ctx> UnwindSafe for Terminal<Pk, Ctx> where
Ctx: RefUnwindSafe,
Pk: RefUnwindSafe + UnwindSafe,
<Pk as MiniscriptKey>::Hash: RefUnwindSafe + UnwindSafe,
[src]
Ctx: RefUnwindSafe,
Pk: RefUnwindSafe + UnwindSafe,
<Pk as MiniscriptKey>::Hash: RefUnwindSafe + UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
[src]
T: ?Sized,
pub fn borrow_mut(&mut self) -> &mut T
[src]
impl<T> From<T> for T
[src]
impl<T, U> Into<U> for T where
U: From<T>,
[src]
U: From<T>,
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
impl<T> ToString for T where
T: Display + ?Sized,
[src]
T: Display + ?Sized,
impl<P, Q, T> TranslatePk1<P, Q> for T where
P: MiniscriptKey,
Q: MiniscriptKey<Hash = <P as MiniscriptKey>::Hash>,
T: TranslatePk<P, Q>,
[src]
P: MiniscriptKey,
Q: MiniscriptKey<Hash = <P as MiniscriptKey>::Hash>,
T: TranslatePk<P, Q>,
pub fn translate_pk1<Fpk, E>(
&self,
translatefpk: Fpk
) -> Result<Self::Output, E> where
Fpk: FnMut(&P) -> Result<Q, E>,
[src]
&self,
translatefpk: Fpk
) -> Result<Self::Output, E> where
Fpk: FnMut(&P) -> Result<Q, E>,
pub fn translate_pk1_infallible<Fpk: FnMut(&P) -> Q>(
&self,
translatefpk: Fpk
) -> Self::Output
[src]
&self,
translatefpk: Fpk
) -> Self::Output
impl<P, Q, T> TranslatePk2<P, Q> for T where
P: MiniscriptKey<Hash = P>,
Q: MiniscriptKey,
T: TranslatePk<P, Q>,
[src]
P: MiniscriptKey<Hash = P>,
Q: MiniscriptKey,
T: TranslatePk<P, Q>,
pub fn translate_pk2<Fpk: Fn(&P) -> Result<Q, E>, E>(
&self,
translatefpk: Fpk
) -> Result<Self::Output, E>
[src]
&self,
translatefpk: Fpk
) -> Result<Self::Output, E>
pub fn translate_pk2_infallible<Fpk: Fn(&P) -> Q>(
&self,
translatefpk: Fpk
) -> Self::Output
[src]
&self,
translatefpk: Fpk
) -> Self::Output
impl<P, Q, T> TranslatePk3<P, Q> for T where
P: MiniscriptKey + ToPublicKey,
Q: MiniscriptKey<Hash = Hash>,
T: TranslatePk<P, Q>,
[src]
P: MiniscriptKey + ToPublicKey,
Q: MiniscriptKey<Hash = Hash>,
T: TranslatePk<P, Q>,
pub fn translate_pk3<Fpk, E>(
&self,
translatefpk: Fpk
) -> Result<Self::Output, E> where
Fpk: FnMut(&P) -> Result<Q, E>,
[src]
&self,
translatefpk: Fpk
) -> Result<Self::Output, E> where
Fpk: FnMut(&P) -> Result<Q, E>,
pub fn translate_pk3_infallible<Fpk: FnMut(&P) -> Q>(
&self,
translatefpk: Fpk
) -> Self::Output
[src]
&self,
translatefpk: Fpk
) -> Self::Output
impl<T, U> TryFrom<U> for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
pub fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,