Enum sapio_miniscript::policy::semantic::Policy

pub enum Policy<Pk: MiniscriptKey> {
    Unsatisfiable,
    Trivial,
    KeyHash(Pk::Hash),
    After(u32),
    Older(u32),
    Sha256(Hash),
    Hash256(Hash),
    Ripemd160(Hash),
    Hash160(Hash),
    Threshold(usize, Vec<Policy<Pk>>),
    TxTemplate(Hash),
}

Abstract policy which corresponds to the semantics of a Miniscript and which allows complex forms of analysis, e.g. filtering and normalization. Semantic policies store only hashes of keys to ensure that objects representing the same policy are lifted to the same Semantic, regardless of their choice of pk or pk_h nodes.

Variants

Unsatisfiable

Unsatisfiable

Trivial

Trivially satisfiable

KeyHash(Pk::Hash)

Signature and public key matching a given hash is required

After(u32)

An absolute locktime restriction

Older(u32)

A relative locktime restriction

Sha256(Hash)

A SHA256 whose preimage must be provided to satisfy the descriptor

Hash256(Hash)

A SHA256d whose preimage must be provided to satisfy the descriptor

Ripemd160(Hash)

A RIPEMD160 whose preimage must be provided to satisfy the descriptor

Hash160(Hash)

A HASH160 whose preimage must be provided to satisfy the descriptor

Threshold(usize, Vec<Policy<Pk>>)

A set of descriptors, satisfactions must be provided for k of them

TxTemplate(Hash)

A SHA256 whose must match the tx template

Implementations

impl<Pk: MiniscriptKey> Policy<Pk>

pub fn translate_pkh<Fpkh, Q, E>(
    &self,
    translatefpkh: Fpkh
) -> Result<Policy<Q>, E> where
    Fpkh: FnMut(&Pk::Hash) -> Result<Q::Hash, E>,
    Q: MiniscriptKey, 

Convert a policy using one kind of public key to another type of public key

Example

use miniscript::{bitcoin::{hashes::hash160, PublicKey}, policy::semantic::Policy};
use std::str::FromStr;
let alice_pkh = "236ada020df3208d2517f4b0db03e16f92cd8cf1";
let bob_pkh = "3e89b972416ae33870b4634d03b8cdc773200cac";
let placeholder_policy = Policy::<String>::from_str("and(pkh(alice_pkh),pkh(bob_pkh))").unwrap();

let real_policy = placeholder_policy.translate_pkh(|placeholder| match placeholder.as_str() {
    "alice_pkh" => hash160::Hash::from_str(alice_pkh),
    "bob_pkh"   => hash160::Hash::from_str(bob_pkh),
    _ => panic!("unknown key hash!")
}).unwrap();

let expected_policy = Policy::<PublicKey>::from_str(&format!("and(pkh({}),pkh({}))", alice_pkh, bob_pkh)).unwrap();
assert_eq!(real_policy, expected_policy);

pub fn entails(self, other: Policy<Pk>) -> Result<bool, PolicyError>

This function computes whether the current policy entails the second one. A |- B means every satisfaction of A is also a satisfaction of B. This implementation will run slow for larger policies but should be sufficient for most practical policies.

impl<Pk: MiniscriptKey> Policy<Pk>

pub fn normalized(self) -> Policy<Pk>

Flatten out trees of Ands and Ors; eliminate Trivial and Unsatisfiables. Does not reorder any branches; use .sort.

pub fn is_trivial(&self) -> bool

Helper function to detect a true/trivial policy This function only checks whether the policy is Policy::Trivial For checking if the normalized form is trivial, the caller is expected to normalize the policy first.

pub fn is_unsatisfiable(&self) -> bool

Helper function to detect a false/unsatisfiable policy This function only checks whether the policy is Policy::Unsatisfiable For checking if the normalized form is unsatisfiable, the caller is expected to normalize the policy first.

pub fn relative_timelocks(&self) -> Vec<u32>

Returns a list of all relative timelocks, not including 0, which appear in the policy

pub fn absolute_timelocks(&self) -> Vec<u32>

Returns a list of all absolute timelocks, not including 0, which appear in the policy

pub fn at_age(self, time: u32) -> Policy<Pk>

Filter a policy by eliminating relative timelock constraints that are not satisfied at the given age.

pub fn at_height(self, time: u32) -> Policy<Pk>

Filter a policy by eliminating absolute timelock constraints that are not satisfied at the given age.

pub fn n_keys(&self) -> usize

Count the number of public keys and keyhashes referenced in a policy. Duplicate keys will be double-counted.

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

Count the minimum number of public keys for which signatures could be used to satisfy the policy. Returns None if the policy is not satisfiable.

impl<Pk: MiniscriptKey> Policy<Pk>

pub fn sorted(self) -> Policy<Pk>

“Sort” a policy to bring it into a canonical form to allow comparisons. Does not allow policies to be compared for functional equivalence; in general this appears to require Gröbner basis techniques that are not implemented.

Trait Implementations

impl<Pk: Clone + MiniscriptKey> Clone for Policy<Pk> where
    Pk::Hash: Clone, 

fn clone(&self) -> Policy<Pk>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Pk: MiniscriptKey> Debug for Policy<Pk>

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

Formats the value using the given formatter.

impl<Pk: MiniscriptKey> Display for Policy<Pk>

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

Formats the value using the given formatter.

impl<Pk: MiniscriptKey> ForEachKey<Pk> for Policy<Pk>

fn for_each_key<'a, F: FnMut(ForEach<'a, Pk>) -> bool>(
    &'a self,
    pred: F
) -> bool where
    Pk: 'a,
    Pk::Hash: 'a, 

Run a predicate on every key in the descriptor, returning whether the predicate returned true for every key

fn for_any_key<'a, F: FnMut(ForEach<'a, Pk>) -> bool>(&'a self, pred: F) -> bool where
    Pk: 'a,
    Pk::Hash: 'a, 

Run a predicate on every key in the descriptor, returning whether the predicate returned true for any key

impl<Pk> FromStr for Policy<Pk> where
    Pk: MiniscriptKey + FromStr,
    Pk::Hash: FromStr,
    <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.

fn from_str(s: &str) -> Result<Policy<Pk>, Error>

Parses a string s to return a value of this type.

impl<Pk> FromTree for Policy<Pk> where
    Pk: MiniscriptKey + FromStr,
    Pk::Hash: FromStr,
    <Pk as FromStr>::Err: ToString,
    <<Pk as MiniscriptKey>::Hash as FromStr>::Err: ToString, 

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

Extract a structure from Tree representation

impl<Pk: MiniscriptKey> Liftable<Pk> for Semantic<Pk>

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

Convert the object into an abstract policy

impl<Pk: Ord + MiniscriptKey> Ord for Policy<Pk> where
    Pk::Hash: Ord, 

fn cmp(&self, other: &Policy<Pk>) -> 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> PartialEq<Policy<Pk>> for Policy<Pk> where
    Pk::Hash: PartialEq, 

fn eq(&self, other: &Policy<Pk>) -> bool

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

fn ne(&self, other: &Policy<Pk>) -> bool

This method tests for !=.

impl<Pk: PartialOrd + MiniscriptKey> PartialOrd<Policy<Pk>> for Policy<Pk> where
    Pk::Hash: PartialOrd, 

fn partial_cmp(&self, other: &Policy<Pk>) -> 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> Eq for Policy<Pk> where
    Pk::Hash: Eq, 

impl<Pk: MiniscriptKey> StructuralEq for Policy<Pk>

impl<Pk: MiniscriptKey> StructuralPartialEq for Policy<Pk>