pub enum Policy<Pk: MiniscriptKey> {
Unsatisfiable,
Trivial,
Key(Pk),
After(PackedLockTime),
Older(Sequence),
Sha256(Pk::Sha256),
Hash256(Pk::Hash256),
Ripemd160(Pk::Ripemd160),
Hash160(Pk::Hash160),
And(Vec<Policy<Pk>>),
Or(Vec<(usize, Policy<Pk>)>),
Threshold(usize, Vec<Policy<Pk>>),
}Expand description
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(PackedLockTime)
An absolute locktime restriction
Older(Sequence)
A relative locktime restriction
Sha256(Pk::Sha256)
A SHA256 whose preimage must be provided to satisfy the descriptor
Hash256(Pk::Hash256)
A SHA256d whose preimage must be provided to satisfy the descriptor
Ripemd160(Pk::Ripemd160)
A RIPEMD160 whose preimage must be provided to satisfy the descriptor
Hash160(Pk::Hash160)
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
Implementations§
Source§impl<Pk> Policy<Pk>where
Pk: MiniscriptKey,
impl<Pk> Policy<Pk>where
Pk: MiniscriptKey,
Source§impl<Pk: MiniscriptKey> Policy<Pk>
impl<Pk: MiniscriptKey> Policy<Pk>
Sourcepub fn translate_pk<Q, E, T>(&self, t: &mut T) -> Result<Policy<Q>, E>where
T: Translator<Pk, Q, E>,
Q: MiniscriptKey,
pub fn translate_pk<Q, E, T>(&self, t: &mut T) -> Result<Policy<Q>, E>where
T: Translator<Pk, 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, Translator, hash256};
use std::str::FromStr;
use miniscript::translate_hash_fail;
use std::collections::HashMap;
use miniscript::bitcoin::hashes::{sha256, hash160, ripemd160};
let alice_key = "0270cf3c71f65a3d93d285d9149fddeeb638f87a2d4d8cf16c525f71c417439777";
let bob_key = "02f43b15c50a436f5335dbea8a64dd3b4e63e34c3b50c42598acb5f4f336b5d2fb";
let placeholder_policy = Policy::<String>::from_str("and(pk(alice_key),pk(bob_key))").unwrap();
// Information to translator abstract String type keys to concrete bitcoin::PublicKey.
// In practice, wallets would map from String key names to BIP32 keys
struct StrPkTranslator {
pk_map: HashMap<String, bitcoin::PublicKey>
}
// If we also wanted to provide mapping of other associated types(sha256, older etc),
// we would use the general Translator Trait.
impl Translator<String, bitcoin::PublicKey, ()> for StrPkTranslator {
// Provides the translation public keys P -> Q
fn pk(&mut self, pk: &String) -> Result<bitcoin::PublicKey, ()> {
self.pk_map.get(pk).copied().ok_or(()) // Dummy Err
}
// Fail for hash types
translate_hash_fail!(String, bitcoin::PublicKey, ());
}
let mut pk_map = HashMap::new();
pk_map.insert(String::from("alice_key"), bitcoin::PublicKey::from_str(alice_key).unwrap());
pk_map.insert(String::from("bob_key"), bitcoin::PublicKey::from_str(bob_key).unwrap());
let mut t = StrPkTranslator { pk_map: pk_map };
let real_policy = placeholder_policy.translate_pk(&mut t).unwrap();
let expected_policy = Policy::from_str(&format!("and(pk({}),pk({}))", alice_key, bob_key)).unwrap();
assert_eq!(real_policy, expected_policy);Sourcepub fn translate_unsatisfiable_pk(self, key: &Pk) -> Policy<Pk>
pub fn translate_unsatisfiable_pk(self, key: &Pk) -> Policy<Pk>
Translate Concrete::Key(key) to Concrete::Unsatisfiable when extracting TapKey
Sourcepub fn check_duplicate_keys(&self) -> Result<(), PolicyError>
pub fn check_duplicate_keys(&self) -> Result<(), PolicyError>
Check whether the policy contains duplicate public keys
Sourcepub fn check_timelocks(&self) -> Result<(), PolicyError>
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.
Sourcepub fn is_valid(&self) -> Result<(), PolicyError>
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
Sourcepub fn is_safe_nonmalleable(&self) -> (bool, bool)
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.