Struct sapio_miniscript::miniscript::types::malleability::Malleability

pub struct Malleability {
    pub dissat: Dissat,
    pub safe: bool,
    pub non_malleable: bool,
}

Structure representing the type properties of a fragment which have relevance to malleability analysis

Fields

dissat: Dissat

Properties of dissatisfying inputs

safe: bool

true if satisfactions cannot be created by any 3rd party who has not yet seen a satisfaction. (Hash preimages and signature checks are safe; timelocks are not.) Affects malleability.

non_malleable: bool

Whether a non-malleable satisfaction is guaranteed to exist for the fragment

Implementations

impl Malleability

pub fn is_subtype(&self, other: Self) -> bool

Check whether the self is a subtype of other argument . This checks whether the argument other has attributes which are present in the given Type. This returns true on same arguments a.is_subtype(a) is true.

Trait Implementations

impl Clone for Malleability

fn clone(&self) -> Malleability

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Malleability

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

Formats the value using the given formatter.

impl Hash for Malleability

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 Ord for Malleability

fn cmp(&self, other: &Malleability) -> 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 PartialEq<Malleability> for Malleability

fn eq(&self, other: &Malleability) -> bool

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

fn ne(&self, other: &Malleability) -> bool

This method tests for !=.

impl PartialOrd<Malleability> for Malleability

fn partial_cmp(&self, other: &Malleability) -> 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 Property for Malleability

fn from_true() -> Self

Type property of the True fragment

fn from_false() -> Self

Type property of the False fragment

fn from_pk_k() -> Self

Type property of the PkK fragment

fn from_pk_h() -> Self

Type property of the PkH fragment

fn from_multi(_: usize, _: usize) -> Self

Type property of a Multi fragment

fn from_hash() -> Self

Type property of a hash fragment

fn from_time(_: u32) -> Self

Type property of a timelock

fn from_txtemplate() -> Self

Type property of a TxTemplate hash. Default implementation simply passes through to from_txtemplate

fn cast_alt(self) -> Result<Self, ErrorKind>

Cast using the Alt wrapper

fn cast_swap(self) -> Result<Self, ErrorKind>

Cast using the Swap wrapper

fn cast_check(self) -> Result<Self, ErrorKind>

Cast using the Check wrapper

fn cast_dupif(self) -> Result<Self, ErrorKind>

Cast using the DupIf wrapper

fn cast_verify(self) -> Result<Self, ErrorKind>

Cast using the Verify wrapper

fn cast_nonzero(self) -> Result<Self, ErrorKind>

Cast using the NonZero wrapper

fn cast_zeronotequal(self) -> Result<Self, ErrorKind>

Cast using the ZeroNotEqual wrapper

fn cast_true(self) -> Result<Self, ErrorKind>

Cast by changing [X] to AndV([X], True)

fn cast_or_i_false(self) -> Result<Self, ErrorKind>

Cast by changing [X] to or_i([X], 0) or or_i(0, [X])

fn and_b(left: Self, right: Self) -> Result<Self, ErrorKind>

Computes the type of an AndB fragment

fn and_v(left: Self, right: Self) -> Result<Self, ErrorKind>

Computes the type of an AndV fragment

fn or_b(left: Self, right: Self) -> Result<Self, ErrorKind>

Computes the type of an OrB fragment

fn or_d(left: Self, right: Self) -> Result<Self, ErrorKind>

Computes the type of an OrD fragment

fn or_c(left: Self, right: Self) -> Result<Self, ErrorKind>

Computes the type of an OrC fragment

fn or_i(left: Self, right: Self) -> Result<Self, ErrorKind>

Computes the type of an OrI fragment

fn and_or(a: Self, b: Self, c: Self) -> Result<Self, ErrorKind>

Computes the type of an AndOr fragment

fn threshold<S>(k: usize, n: usize, sub_ck: S) -> Result<Self, ErrorKind> where
    S: FnMut(usize) -> Result<Self, ErrorKind>, 

Computes the type of an Thresh fragment

fn sanity_checks(&self)

Any extra sanity checks/assertions that should be applied after typechecking

fn from_multi_a(k: usize, n: usize) -> Self

Type property of a MultiA fragment

fn from_sha256() -> Self

Type property of a Sha256 hash. Default implementation simply passes through to from_hash

fn from_hash256() -> Self

Type property of a Hash256 hash. Default implementation simply passes through to from_hash

fn from_ripemd160() -> Self

Type property of a Ripemd160 hash. Default implementation simply passes through to from_hash

fn from_hash160() -> Self

Type property of a Hash160 hash. Default implementation simply passes through to from_hash

fn from_after(t: u32) -> Self

Type property of a relative timelock. Default implementation simply passes through to from_time

fn from_older(t: u32) -> Self

Type property of an absolute timelock. Default implementation simply passes through to from_time

fn cast_unlikely(self) -> Result<Self, ErrorKind>

Cast by changing [X] to or_i([X], 0). Default implementation simply passes through to cast_or_i_false

fn cast_likely(self) -> Result<Self, ErrorKind>

Cast by changing [X] to or_i(0, [X]). Default implementation simply passes through to cast_or_i_false

fn and_n(left: Self, right: Self) -> Result<Self, ErrorKind>

Computes the type of an AndN fragment

fn type_check<Pk, Ctx, C>(
    fragment: &Terminal<Pk, Ctx>,
    child: C
) -> Result<Self, Error<Pk, Ctx>> where
    C: FnMut(usize) -> Option<Self>,
    Pk: MiniscriptKey,
    Ctx: ScriptContext, 

Compute the type of a fragment, given a function to look up the types of its children, if available and relevant for the given fragment

impl Copy for Malleability

impl Eq for Malleability

impl StructuralEq for Malleability

impl StructuralPartialEq for Malleability