Enum Policy 

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

Concrete policy which corresponds directly to a Miniscript structure, and whose disjunctions are annotated with satisfaction probabilities to assist the compiler

Variants

Unsatisfiable

Unsatisfiable

Trivial

Trivially satisfiable

Key(Pk)

A public key which must sign to satisfy the descriptor

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

And(Vec<Policy<Pk>>)

A list of sub-policies, all of which must be satisfied

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

A list of sub-policies, one of which must be satisfied, along with relative probabilities for each one

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_pk<Fpk, Q, E>(&self, translatefpk: Fpk) -> Result<Policy<Q>, E>

where Fpk: FnMut(&Pk) -> Result<Q, E>, Q: MiniscriptKey,

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

Example

use miniscript::{bitcoin::PublicKey, policy::concrete::Policy};
use std::str::FromStr;
let alice_key = "0270cf3c71f65a3d93d285d9149fddeeb638f87a2d4d8cf16c525f71c417439777";
let bob_key = "02f43b15c50a436f5335dbea8a64dd3b4e63e34c3b50c42598acb5f4f336b5d2fb";
let placeholder_policy = Policy::<String>::from_str("and(pk(alice_key),pk(bob_key))").unwrap();

let real_policy = placeholder_policy.translate_pk(|placeholder: &String| match placeholder.as_str() {
    "alice_key" => PublicKey::from_str(alice_key),
    "bob_key"   => PublicKey::from_str(bob_key),
    _ => panic!("unknown key!")
}).unwrap();

let expected_policy = Policy::from_str(&format!("and(pk({}),pk({}))", alice_key, bob_key)).unwrap();
assert_eq!(real_policy, expected_policy);

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

Get all keys in the policy

pub fn check_duplicate_keys(&self) -> Result<(), PolicyError>

Check whether the policy contains duplicate public keys

pub fn check_timelocks(&self) -> Result<(), PolicyError>

Checks whether the given concrete policy contains a combination of timelocks and heightlocks. Returns an error if there is at least one satisfaction that contains a combination of hieghtlock and timelock.

pub fn is_valid(&self) -> Result<(), PolicyError>

This returns whether the given policy is valid or not. It maybe possible that the policy contains Non-two argument and, or or a 0 arg thresh. Validity condition also checks whether there is a possible satisfaction combination of timelocks and heightlocks

pub fn is_safe_nonmalleable(&self) -> (bool, bool)

This returns whether any possible compilation of the policy could be compiled as non-malleable and safe. Note that this returns a tuple (safe, non-malleable) to avoid because the non-malleability depends on safety and we would like to cache results.

Trait Implementations

impl<Pk: Clone + MiniscriptKey> Clone for Policy<Pk>

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

Returns a duplicate 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,

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

Extract a structure from Tree representation

impl<Pk: Hash + MiniscriptKey> Hash for Policy<Pk>

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

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

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

Convert the object into an abstract policy

impl<Pk: Ord + MiniscriptKey> Ord for Policy<Pk>

fn cmp(&self, other: &Policy<Pk>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<Pk: PartialEq + MiniscriptKey> PartialEq for Policy<Pk>

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Pk: PartialOrd + MiniscriptKey> PartialOrd for Policy<Pk>

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

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

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

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

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

impl<Pk: Eq + MiniscriptKey> Eq for Policy<Pk>

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