diff --git a/bitcoind-tests/tests/setup/test_util.rs b/bitcoind-tests/tests/setup/test_util.rs
index 3b77047a0..e844e7fd8 100644
--- a/bitcoind-tests/tests/setup/test_util.rs
+++ b/bitcoind-tests/tests/setup/test_util.rs
@@ -25,8 +25,8 @@ use bitcoin::secp256k1;
 use internals::hex::exts::DisplayHex;
 use miniscript::descriptor::{SinglePub, SinglePubKey};
 use miniscript::{
-    bitcoin, hash256, Descriptor, DescriptorPublicKey, Error, Miniscript, ScriptContext,
-    TranslatePk, Translator,
+    bitcoin, hash256, Context, Descriptor, DescriptorPublicKey, Error, Miniscript, TranslatePk,
+    Translator,
 };
 use rand::RngCore;
 use secp256k1::XOnlyPublicKey;
@@ -150,7 +150,7 @@ pub fn random_pk(mut seed: u8) -> bitcoin::PublicKey {
 #[allow(dead_code)]
 // https://github.com/rust-lang/rust/issues/46379. The code is pub fn and integration test, but still shows warnings
 /// Parse an insane miniscript into a miniscript with the format described above at file header
-pub fn parse_insane_ms<Ctx: ScriptContext>(
+pub fn parse_insane_ms<Ctx: Context>(
     ms: &str,
     pubdata: &PubData,
 ) -> Miniscript<DescriptorPublicKey, Ctx> {
diff --git a/bitcoind-tests/tests/test_desc.rs b/bitcoind-tests/tests/test_desc.rs
index 06c8e8f82..e5ca47178 100644
--- a/bitcoind-tests/tests/test_desc.rs
+++ b/bitcoind-tests/tests/test_desc.rs
@@ -19,7 +19,7 @@ use bitcoin::{
 use bitcoind::bitcoincore_rpc::{json, Client, RpcApi};
 use miniscript::bitcoin::{self, ecdsa, taproot, ScriptBuf};
 use miniscript::psbt::{PsbtExt, PsbtInputExt};
-use miniscript::{Descriptor, Miniscript, ScriptContext, ToPublicKey};
+use miniscript::{Context, Descriptor, Miniscript, ToPublicKey};
 mod setup;
 
 use rand::RngCore;
@@ -318,7 +318,7 @@ pub fn test_desc_satisfy(
 }
 
 // Find all secret corresponding to the known public keys in ms
-fn find_sks_ms<Ctx: ScriptContext>(
+fn find_sks_ms<Ctx: Context>(
     ms: &Miniscript<bitcoin::PublicKey, Ctx>,
     testdata: &TestData,
 ) -> Vec<secp256k1::SecretKey> {
diff --git a/examples/sign_multisig.rs b/examples/sign_multisig.rs
index 1e913f609..022f5d74a 100644
--- a/examples/sign_multisig.rs
+++ b/examples/sign_multisig.rs
@@ -23,7 +23,7 @@ fn main() {
     assert_eq!(descriptor.max_weight_to_satisfy().unwrap(), 253);
 
     // Sometimes it is necessary to have additional information to get the
-    // `bitcoin::PublicKey` from the `MiniscriptKey` which can be supplied by
+    // `bitcoin::PublicKey` from the `Key` which can be supplied by
     // the `to_pk_ctx` parameter. For example, when calculating the script
     // pubkey of a descriptor with xpubs, the secp context and child information
     // maybe required.
diff --git a/src/descriptor/bare.rs b/src/descriptor/bare.rs
index a8028fe60..8d50d6136 100644
--- a/src/descriptor/bare.rs
+++ b/src/descriptor/bare.rs
@@ -14,24 +14,24 @@ use bitcoin::{Address, Network, ScriptBuf};
 
 use super::checksum::{self, verify_checksum};
 use crate::expression::{self, FromTree};
-use crate::miniscript::context::{ScriptContext, ScriptContextError};
+use crate::miniscript::context::{Context, ContextError};
 use crate::policy::{semantic, Liftable};
 use crate::prelude::*;
 use crate::util::{varint_len, witness_to_scriptsig};
 use crate::{
-    BareCtx, Error, ForEachKey, Miniscript, MiniscriptKey, Satisfier, ToPublicKey, TranslateErr,
-    TranslatePk, Translator,
+    BareCtx, Error, ForEachKey, Key, Miniscript, Satisfier, ToPublicKey, TranslateErr, TranslatePk,
+    Translator,
 };
 
 /// Create a Bare Descriptor. That is descriptor that is
 /// not wrapped in sh or wsh. This covers the Pk descriptor
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
-pub struct Bare<Pk: MiniscriptKey> {
+pub struct Bare<Pk: Key> {
     /// underlying miniscript
     ms: Miniscript<Pk, BareCtx>,
 }
 
-impl<Pk: MiniscriptKey> Bare<Pk> {
+impl<Pk: Key> Bare<Pk> {
     /// Create a new raw descriptor
     pub fn new(ms: Miniscript<Pk, BareCtx>) -> Result<Self, Error> {
         // do the top-level checks
@@ -91,7 +91,7 @@ impl<Pk: MiniscriptKey> Bare<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey + ToPublicKey> Bare<Pk> {
+impl<Pk: Key + ToPublicKey> Bare<Pk> {
     /// Obtains the corresponding script pubkey for this descriptor.
     pub fn script_pubkey(&self) -> ScriptBuf {
         self.ms.encode()
@@ -134,13 +134,13 @@ impl<Pk: MiniscriptKey + ToPublicKey> Bare<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey> fmt::Debug for Bare<Pk> {
+impl<Pk: Key> fmt::Debug for Bare<Pk> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{:?}", self.ms)
     }
 }
 
-impl<Pk: MiniscriptKey> fmt::Display for Bare<Pk> {
+impl<Pk: Key> fmt::Display for Bare<Pk> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use fmt::Write;
         let mut wrapped_f = checksum::Formatter::new(f);
@@ -149,7 +149,7 @@ impl<Pk: MiniscriptKey> fmt::Display for Bare<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey> Liftable<Pk> for Bare<Pk> {
+impl<Pk: Key> Liftable<Pk> for Bare<Pk> {
     fn lift(&self) -> Result<semantic::Policy<Pk>, Error> {
         self.ms.lift()
     }
@@ -174,17 +174,13 @@ impl_from_str!(
     }
 );
 
-impl<Pk: MiniscriptKey> ForEachKey<Pk> for Bare<Pk> {
+impl<Pk: Key> ForEachKey<Pk> for Bare<Pk> {
     fn for_each_key<'a, F: FnMut(&'a Pk) -> bool>(&'a self, pred: F) -> bool {
         self.ms.for_each_key(pred)
     }
 }
 
-impl<P, Q> TranslatePk<P, Q> for Bare<P>
-where
-    P: MiniscriptKey,
-    Q: MiniscriptKey,
-{
+impl<P: Key, Q: Key> TranslatePk<P, Q> for Bare<P> {
     type Output = Bare<Q>;
 
     fn translate_pk<T, E>(&self, t: &mut T) -> Result<Bare<Q>, TranslateErr<E>>
@@ -197,14 +193,14 @@ where
 
 /// A bare PkH descriptor at top level
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
-pub struct Pkh<Pk: MiniscriptKey> {
+pub struct Pkh<Pk: Key> {
     /// underlying publickey
     pk: Pk,
 }
 
-impl<Pk: MiniscriptKey> Pkh<Pk> {
+impl<Pk: Key> Pkh<Pk> {
     /// Create a new Pkh descriptor
-    pub fn new(pk: Pk) -> Result<Self, ScriptContextError> {
+    pub fn new(pk: Pk) -> Result<Self, ContextError> {
         // do the top-level checks
         match BareCtx::check_pk(&pk) {
             Ok(()) => Ok(Pkh { pk }),
@@ -254,7 +250,7 @@ impl<Pk: MiniscriptKey> Pkh<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey + ToPublicKey> Pkh<Pk> {
+impl<Pk: Key + ToPublicKey> Pkh<Pk> {
     /// Obtains the corresponding script pubkey for this descriptor.
     pub fn script_pubkey(&self) -> ScriptBuf {
         // Fine to hard code the `Network` here because we immediately call
@@ -311,13 +307,13 @@ impl<Pk: MiniscriptKey + ToPublicKey> Pkh<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey> fmt::Debug for Pkh<Pk> {
+impl<Pk: Key> fmt::Debug for Pkh<Pk> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "pkh({:?})", self.pk)
     }
 }
 
-impl<Pk: MiniscriptKey> fmt::Display for Pkh<Pk> {
+impl<Pk: Key> fmt::Display for Pkh<Pk> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use fmt::Write;
         let mut wrapped_f = checksum::Formatter::new(f);
@@ -326,7 +322,7 @@ impl<Pk: MiniscriptKey> fmt::Display for Pkh<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey> Liftable<Pk> for Pkh<Pk> {
+impl<Pk: Key> Liftable<Pk> for Pkh<Pk> {
     fn lift(&self) -> Result<semantic::Policy<Pk>, Error> {
         Ok(semantic::Policy::Key(self.pk.clone()))
     }
@@ -359,17 +355,13 @@ impl_from_str!(
     }
 );
 
-impl<Pk: MiniscriptKey> ForEachKey<Pk> for Pkh<Pk> {
+impl<Pk: Key> ForEachKey<Pk> for Pkh<Pk> {
     fn for_each_key<'a, F: FnMut(&'a Pk) -> bool>(&'a self, mut pred: F) -> bool {
         pred(&self.pk)
     }
 }
 
-impl<P, Q> TranslatePk<P, Q> for Pkh<P>
-where
-    P: MiniscriptKey,
-    Q: MiniscriptKey,
-{
+impl<P: Key, Q: Key> TranslatePk<P, Q> for Pkh<P> {
     type Output = Pkh<Q>;
 
     fn translate_pk<T, E>(&self, t: &mut T) -> Result<Self::Output, TranslateErr<E>>
diff --git a/src/descriptor/key.rs b/src/descriptor/key.rs
index 83308e0dc..d659ecbe0 100644
--- a/src/descriptor/key.rs
+++ b/src/descriptor/key.rs
@@ -16,7 +16,7 @@ use bitcoin::secp256k1::{Secp256k1, Signing, Verification};
 use crate::prelude::*;
 #[cfg(feature = "serde")]
 use crate::serde::{Deserialize, Deserializer, Serialize, Serializer};
-use crate::{hash256, MiniscriptKey, ToPublicKey};
+use crate::{hash256, Key, ToPublicKey};
 
 /// The descriptor pubkey, either a single pubkey or an xpub.
 #[derive(Debug, Eq, PartialEq, Clone, Ord, PartialOrd, Hash)]
@@ -982,7 +982,7 @@ impl<K: InnerXKey> DescriptorXKey<K> {
     }
 }
 
-impl MiniscriptKey for DescriptorPublicKey {
+impl Key for DescriptorPublicKey {
     type Sha256 = sha256::Hash;
     type Hash256 = hash256::Hash;
     type Ripemd160 = ripemd160::Hash;
@@ -1103,7 +1103,7 @@ impl fmt::Display for DefiniteDescriptorKey {
     }
 }
 
-impl MiniscriptKey for DefiniteDescriptorKey {
+impl Key for DefiniteDescriptorKey {
     type Sha256 = sha256::Hash;
     type Hash256 = hash256::Hash;
     type Ripemd160 = ripemd160::Hash;
@@ -1188,7 +1188,7 @@ mod test {
 
     use super::{
         DescriptorKeyParseError, DescriptorMultiXKey, DescriptorPublicKey, DescriptorSecretKey,
-        MiniscriptKey, Wildcard,
+        Key, Wildcard,
     };
     use crate::prelude::*;
 
diff --git a/src/descriptor/mod.rs b/src/descriptor/mod.rs
index 4ccf50f18..91e41a051 100644
--- a/src/descriptor/mod.rs
+++ b/src/descriptor/mod.rs
@@ -25,8 +25,8 @@ use crate::miniscript::decode::Terminal;
 use crate::miniscript::{Legacy, Miniscript, Segwitv0};
 use crate::prelude::*;
 use crate::{
-    expression, hash256, BareCtx, Error, ForEachKey, MiniscriptKey, Satisfier, ToPublicKey,
-    TranslateErr, TranslatePk, Translator,
+    expression, hash256, BareCtx, Error, ForEachKey, Key, Satisfier, ToPublicKey, TranslateErr,
+    TranslatePk, Translator,
 };
 
 mod bare;
@@ -61,7 +61,7 @@ pub type KeyMap = HashMap<DescriptorPublicKey, DescriptorSecretKey>;
 
 /// Script descriptor
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum Descriptor<Pk: MiniscriptKey> {
+pub enum Descriptor<Pk: Key> {
     /// A raw scriptpubkey (including pay-to-pubkey) under Legacy context
     Bare(Bare<Pk>),
     /// Pay-to-PubKey-Hash
@@ -76,42 +76,42 @@ pub enum Descriptor<Pk: MiniscriptKey> {
     Tr(Tr<Pk>),
 }
 
-impl<Pk: MiniscriptKey> From<Bare<Pk>> for Descriptor<Pk> {
+impl<Pk: Key> From<Bare<Pk>> for Descriptor<Pk> {
     #[inline]
     fn from(inner: Bare<Pk>) -> Self {
         Descriptor::Bare(inner)
     }
 }
 
-impl<Pk: MiniscriptKey> From<Pkh<Pk>> for Descriptor<Pk> {
+impl<Pk: Key> From<Pkh<Pk>> for Descriptor<Pk> {
     #[inline]
     fn from(inner: Pkh<Pk>) -> Self {
         Descriptor::Pkh(inner)
     }
 }
 
-impl<Pk: MiniscriptKey> From<Wpkh<Pk>> for Descriptor<Pk> {
+impl<Pk: Key> From<Wpkh<Pk>> for Descriptor<Pk> {
     #[inline]
     fn from(inner: Wpkh<Pk>) -> Self {
         Descriptor::Wpkh(inner)
     }
 }
 
-impl<Pk: MiniscriptKey> From<Sh<Pk>> for Descriptor<Pk> {
+impl<Pk: Key> From<Sh<Pk>> for Descriptor<Pk> {
     #[inline]
     fn from(inner: Sh<Pk>) -> Self {
         Descriptor::Sh(inner)
     }
 }
 
-impl<Pk: MiniscriptKey> From<Wsh<Pk>> for Descriptor<Pk> {
+impl<Pk: Key> From<Wsh<Pk>> for Descriptor<Pk> {
     #[inline]
     fn from(inner: Wsh<Pk>) -> Self {
         Descriptor::Wsh(inner)
     }
 }
 
-impl<Pk: MiniscriptKey> From<Tr<Pk>> for Descriptor<Pk> {
+impl<Pk: Key> From<Tr<Pk>> for Descriptor<Pk> {
     #[inline]
     fn from(inner: Tr<Pk>) -> Self {
         Descriptor::Tr(inner)
@@ -161,7 +161,7 @@ impl DescriptorType {
     }
 }
 
-impl<Pk: MiniscriptKey> Descriptor<Pk> {
+impl<Pk: Key> Descriptor<Pk> {
     // Keys
 
     /// Create a new pk descriptor
@@ -378,7 +378,7 @@ impl<Pk: MiniscriptKey> Descriptor<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey + ToPublicKey> Descriptor<Pk> {
+impl<Pk: Key + ToPublicKey> Descriptor<Pk> {
     /// Computes the Bitcoin address of the descriptor, if one exists
     ///
     /// Some descriptors like pk() don't have an address.
@@ -509,11 +509,7 @@ impl<Pk: MiniscriptKey + ToPublicKey> Descriptor<Pk> {
     }
 }
 
-impl<P, Q> TranslatePk<P, Q> for Descriptor<P>
-where
-    P: MiniscriptKey,
-    Q: MiniscriptKey,
-{
+impl<P: Key, Q: Key> TranslatePk<P, Q> for Descriptor<P> {
     type Output = Descriptor<Q>;
 
     /// Converts a descriptor using abstract keys to one using specific keys.
@@ -533,7 +529,7 @@ where
     }
 }
 
-impl<Pk: MiniscriptKey> ForEachKey<Pk> for Descriptor<Pk> {
+impl<Pk: Key> ForEachKey<Pk> for Descriptor<Pk> {
     fn for_each_key<'a, F: FnMut(&'a Pk) -> bool>(&'a self, pred: F) -> bool {
         match *self {
             Descriptor::Bare(ref bare) => bare.for_each_key(pred),
@@ -919,7 +915,7 @@ impl_from_str!(
     }
 );
 
-impl<Pk: MiniscriptKey> fmt::Debug for Descriptor<Pk> {
+impl<Pk: Key> fmt::Debug for Descriptor<Pk> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             Descriptor::Bare(ref sub) => fmt::Debug::fmt(sub, f),
@@ -932,7 +928,7 @@ impl<Pk: MiniscriptKey> fmt::Debug for Descriptor<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey> fmt::Display for Descriptor<Pk> {
+impl<Pk: Key> fmt::Display for Descriptor<Pk> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             Descriptor::Bare(ref sub) => fmt::Display::fmt(sub, f),
diff --git a/src/descriptor/segwitv0.rs b/src/descriptor/segwitv0.rs
index 4d7c4e7a3..135abc39c 100644
--- a/src/descriptor/segwitv0.rs
+++ b/src/descriptor/segwitv0.rs
@@ -12,22 +12,22 @@ use bitcoin::{Address, Network, ScriptBuf};
 use super::checksum::{self, verify_checksum};
 use super::SortedMultiVec;
 use crate::expression::{self, FromTree};
-use crate::miniscript::context::{ScriptContext, ScriptContextError};
+use crate::miniscript::context::{Context, ContextError};
 use crate::policy::{semantic, Liftable};
 use crate::prelude::*;
 use crate::util::varint_len;
 use crate::{
-    Error, ForEachKey, Miniscript, MiniscriptKey, Satisfier, Segwitv0, ToPublicKey, TranslateErr,
+    Error, ForEachKey, Key, Miniscript, Satisfier, Segwitv0, ToPublicKey, TranslateErr,
     TranslatePk, Translator,
 };
 /// A Segwitv0 wsh descriptor
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
-pub struct Wsh<Pk: MiniscriptKey> {
+pub struct Wsh<Pk: Key> {
     /// underlying miniscript
     inner: WshInner<Pk>,
 }
 
-impl<Pk: MiniscriptKey> Wsh<Pk> {
+impl<Pk: Key> Wsh<Pk> {
     /// Get the Inner
     pub fn into_inner(self) -> WshInner<Pk> {
         self.inner
@@ -130,7 +130,7 @@ impl<Pk: MiniscriptKey> Wsh<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey + ToPublicKey> Wsh<Pk> {
+impl<Pk: Key + ToPublicKey> Wsh<Pk> {
     /// Obtains the corresponding script pubkey for this descriptor.
     pub fn script_pubkey(&self) -> ScriptBuf {
         self.inner_script().to_v0_p2wsh()
@@ -193,14 +193,14 @@ impl<Pk: MiniscriptKey + ToPublicKey> Wsh<Pk> {
 
 /// Wsh Inner
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
-pub enum WshInner<Pk: MiniscriptKey> {
+pub enum WshInner<Pk: Key> {
     /// Sorted Multi
     SortedMulti(SortedMultiVec<Pk, Segwitv0>),
     /// Wsh Miniscript
     Ms(Miniscript<Pk, Segwitv0>),
 }
 
-impl<Pk: MiniscriptKey> Liftable<Pk> for Wsh<Pk> {
+impl<Pk: Key> Liftable<Pk> for Wsh<Pk> {
     fn lift(&self) -> Result<semantic::Policy<Pk>, Error> {
         match self.inner {
             WshInner::SortedMulti(ref smv) => smv.lift(),
@@ -234,7 +234,7 @@ impl_from_tree!(
     }
 );
 
-impl<Pk: MiniscriptKey> fmt::Debug for Wsh<Pk> {
+impl<Pk: Key> fmt::Debug for Wsh<Pk> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self.inner {
             WshInner::SortedMulti(ref smv) => write!(f, "wsh({:?})", smv),
@@ -243,7 +243,7 @@ impl<Pk: MiniscriptKey> fmt::Debug for Wsh<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey> fmt::Display for Wsh<Pk> {
+impl<Pk: Key> fmt::Display for Wsh<Pk> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use fmt::Write;
         let mut wrapped_f = checksum::Formatter::new(f);
@@ -265,7 +265,7 @@ impl_from_str!(
     }
 );
 
-impl<Pk: MiniscriptKey> ForEachKey<Pk> for Wsh<Pk> {
+impl<Pk: Key> ForEachKey<Pk> for Wsh<Pk> {
     fn for_each_key<'a, F: FnMut(&'a Pk) -> bool>(&'a self, pred: F) -> bool {
         match self.inner {
             WshInner::SortedMulti(ref smv) => smv.for_each_key(pred),
@@ -274,11 +274,7 @@ impl<Pk: MiniscriptKey> ForEachKey<Pk> for Wsh<Pk> {
     }
 }
 
-impl<P, Q> TranslatePk<P, Q> for Wsh<P>
-where
-    P: MiniscriptKey,
-    Q: MiniscriptKey,
-{
+impl<P: Key, Q: Key> TranslatePk<P, Q> for Wsh<P> {
     type Output = Wsh<Q>;
 
     fn translate_pk<T, E>(&self, t: &mut T) -> Result<Self::Output, TranslateErr<E>>
@@ -295,14 +291,14 @@ where
 
 /// A bare Wpkh descriptor at top level
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
-pub struct Wpkh<Pk: MiniscriptKey> {
+pub struct Wpkh<Pk: Key> {
     /// underlying publickey
     pk: Pk,
 }
 
-impl<Pk: MiniscriptKey> Wpkh<Pk> {
+impl<Pk: Key> Wpkh<Pk> {
     /// Create a new Wpkh descriptor
-    pub fn new(pk: Pk) -> Result<Self, ScriptContextError> {
+    pub fn new(pk: Pk) -> Result<Self, ContextError> {
         // do the top-level checks
         match Segwitv0::check_pk(&pk) {
             Ok(_) => Ok(Wpkh { pk }),
@@ -329,7 +325,7 @@ impl<Pk: MiniscriptKey> Wpkh<Pk> {
     /// Checks whether the descriptor is safe.
     pub fn sanity_check(&self) -> Result<(), Error> {
         if self.pk.is_uncompressed() {
-            Err(Error::ContextError(ScriptContextError::CompressedOnly(
+            Err(Error::ContextError(ContextError::CompressedOnly(
                 self.pk.to_string(),
             )))
         } else {
@@ -361,7 +357,7 @@ impl<Pk: MiniscriptKey> Wpkh<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey + ToPublicKey> Wpkh<Pk> {
+impl<Pk: Key + ToPublicKey> Wpkh<Pk> {
     /// Obtains the corresponding script pubkey for this descriptor.
     pub fn script_pubkey(&self) -> ScriptBuf {
         let addr = Address::p2wpkh(&self.pk.to_public_key(), Network::Bitcoin)
@@ -418,13 +414,13 @@ impl<Pk: MiniscriptKey + ToPublicKey> Wpkh<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey> fmt::Debug for Wpkh<Pk> {
+impl<Pk: Key> fmt::Debug for Wpkh<Pk> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "wpkh({:?})", self.pk)
     }
 }
 
-impl<Pk: MiniscriptKey> fmt::Display for Wpkh<Pk> {
+impl<Pk: Key> fmt::Display for Wpkh<Pk> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use fmt::Write;
         let mut wrapped_f = checksum::Formatter::new(f);
@@ -433,7 +429,7 @@ impl<Pk: MiniscriptKey> fmt::Display for Wpkh<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey> Liftable<Pk> for Wpkh<Pk> {
+impl<Pk: Key> Liftable<Pk> for Wpkh<Pk> {
     fn lift(&self) -> Result<semantic::Policy<Pk>, Error> {
         Ok(semantic::Policy::Key(self.pk.clone()))
     }
@@ -466,17 +462,13 @@ impl_from_str!(
     }
 );
 
-impl<Pk: MiniscriptKey> ForEachKey<Pk> for Wpkh<Pk> {
+impl<Pk: Key> ForEachKey<Pk> for Wpkh<Pk> {
     fn for_each_key<'a, F: FnMut(&'a Pk) -> bool>(&'a self, mut pred: F) -> bool {
         pred(&self.pk)
     }
 }
 
-impl<P, Q> TranslatePk<P, Q> for Wpkh<P>
-where
-    P: MiniscriptKey,
-    Q: MiniscriptKey,
-{
+impl<P: Key, Q: Key> TranslatePk<P, Q> for Wpkh<P> {
     type Output = Wpkh<Q>;
 
     fn translate_pk<T, E>(&self, t: &mut T) -> Result<Self::Output, TranslateErr<E>>
diff --git a/src/descriptor/sh.rs b/src/descriptor/sh.rs
index 1f18c641a..fcf00bb5f 100644
--- a/src/descriptor/sh.rs
+++ b/src/descriptor/sh.rs
@@ -16,25 +16,25 @@ use bitcoin::{script, Address, Network, ScriptBuf};
 use super::checksum::{self, verify_checksum};
 use super::{SortedMultiVec, Wpkh, Wsh};
 use crate::expression::{self, FromTree};
-use crate::miniscript::context::ScriptContext;
+use crate::miniscript::context::Context;
 use crate::policy::{semantic, Liftable};
 use crate::prelude::*;
 use crate::util::{varint_len, witness_to_scriptsig};
 use crate::{
-    push_opcode_size, Error, ForEachKey, Legacy, Miniscript, MiniscriptKey, Satisfier, Segwitv0,
-    ToPublicKey, TranslateErr, TranslatePk, Translator,
+    push_opcode_size, Error, ForEachKey, Key, Legacy, Miniscript, Satisfier, Segwitv0, ToPublicKey,
+    TranslateErr, TranslatePk, Translator,
 };
 
 /// A Legacy p2sh Descriptor
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
-pub struct Sh<Pk: MiniscriptKey> {
+pub struct Sh<Pk: Key> {
     /// underlying miniscript
     inner: ShInner<Pk>,
 }
 
 /// Sh Inner
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
-pub enum ShInner<Pk: MiniscriptKey> {
+pub enum ShInner<Pk: Key> {
     /// Nested Wsh
     Wsh(Wsh<Pk>),
     /// Nested Wpkh
@@ -45,7 +45,7 @@ pub enum ShInner<Pk: MiniscriptKey> {
     Ms(Miniscript<Pk, Legacy>),
 }
 
-impl<Pk: MiniscriptKey> Liftable<Pk> for Sh<Pk> {
+impl<Pk: Key> Liftable<Pk> for Sh<Pk> {
     fn lift(&self) -> Result<semantic::Policy<Pk>, Error> {
         match self.inner {
             ShInner::Wsh(ref wsh) => wsh.lift(),
@@ -56,7 +56,7 @@ impl<Pk: MiniscriptKey> Liftable<Pk> for Sh<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey> fmt::Debug for Sh<Pk> {
+impl<Pk: Key> fmt::Debug for Sh<Pk> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self.inner {
             ShInner::Wsh(ref wsh_inner) => write!(f, "sh({:?})", wsh_inner),
@@ -67,7 +67,7 @@ impl<Pk: MiniscriptKey> fmt::Debug for Sh<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey> fmt::Display for Sh<Pk> {
+impl<Pk: Key> fmt::Display for Sh<Pk> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use fmt::Write;
         let mut wrapped_f = checksum::Formatter::new(f);
@@ -117,7 +117,7 @@ impl_from_str!(
     }
 );
 
-impl<Pk: MiniscriptKey> Sh<Pk> {
+impl<Pk: Key> Sh<Pk> {
     /// Get the Inner
     pub fn into_inner(self) -> ShInner<Pk> {
         self.inner
@@ -278,7 +278,7 @@ impl<Pk: MiniscriptKey> Sh<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey + ToPublicKey> Sh<Pk> {
+impl<Pk: Key + ToPublicKey> Sh<Pk> {
     /// Obtains the corresponding script pubkey for this descriptor.
     pub fn script_pubkey(&self) -> ScriptBuf {
         match self.inner {
@@ -418,7 +418,7 @@ impl<Pk: MiniscriptKey + ToPublicKey> Sh<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey> ForEachKey<Pk> for Sh<Pk> {
+impl<Pk: Key> ForEachKey<Pk> for Sh<Pk> {
     fn for_each_key<'a, F: FnMut(&'a Pk) -> bool>(&'a self, pred: F) -> bool {
         match self.inner {
             ShInner::Wsh(ref wsh) => wsh.for_each_key(pred),
@@ -429,11 +429,7 @@ impl<Pk: MiniscriptKey> ForEachKey<Pk> for Sh<Pk> {
     }
 }
 
-impl<P, Q> TranslatePk<P, Q> for Sh<P>
-where
-    P: MiniscriptKey,
-    Q: MiniscriptKey,
-{
+impl<P: Key, Q: Key> TranslatePk<P, Q> for Sh<P> {
     type Output = Sh<Q>;
 
     fn translate_pk<T, E>(&self, t: &mut T) -> Result<Self::Output, TranslateErr<E>>
diff --git a/src/descriptor/sortedmulti.rs b/src/descriptor/sortedmulti.rs
index b626c1c9a..01ee071ae 100644
--- a/src/descriptor/sortedmulti.rs
+++ b/src/descriptor/sortedmulti.rs
@@ -11,27 +11,27 @@ use core::str::FromStr;
 
 use bitcoin::script;
 
-use crate::miniscript::context::ScriptContext;
+use crate::miniscript::context::Context;
 use crate::miniscript::decode::Terminal;
 use crate::miniscript::limits::MAX_PUBKEYS_PER_MULTISIG;
 use crate::prelude::*;
 use crate::{
-    errstr, expression, policy, script_num_size, Error, ForEachKey, Miniscript, MiniscriptKey,
-    Satisfier, ToPublicKey, TranslateErr, Translator,
+    errstr, expression, policy, script_num_size, Error, ForEachKey, Key, Miniscript, Satisfier,
+    ToPublicKey, TranslateErr, Translator,
 };
 
 /// Contents of a "sortedmulti" descriptor
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct SortedMultiVec<Pk: MiniscriptKey, Ctx: ScriptContext> {
+pub struct SortedMultiVec<Pk: Key, Ctx: Context> {
     /// signatures required
     pub k: usize,
     /// public keys inside sorted Multi
     pub pks: Vec<Pk>,
-    /// The current ScriptContext for sortedmulti
+    /// The current Context for sortedmulti
     pub(crate) phantom: PhantomData<Ctx>,
 }
 
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> SortedMultiVec<Pk, Ctx> {
+impl<Pk: Key, Ctx: Context> SortedMultiVec<Pk, Ctx> {
     /// Create a new instance of `SortedMultiVec` given a list of keys and the threshold
     ///
     /// Internally checks all the applicable size limits and pubkey types limitations according to the current `Ctx`.
@@ -89,7 +89,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> SortedMultiVec<Pk, Ctx> {
     ) -> Result<SortedMultiVec<Q, Ctx>, TranslateErr<FuncError>>
     where
         T: Translator<Pk, Q, FuncError>,
-        Q: MiniscriptKey,
+        Q: Key,
     {
         let pks: Result<Vec<Q>, _> = self.pks.iter().map(|pk| t.pk(pk)).collect();
         let res = SortedMultiVec::new(self.k, pks?).map_err(TranslateErr::OuterError)?;
@@ -97,13 +97,13 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> SortedMultiVec<Pk, Ctx> {
     }
 }
 
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> ForEachKey<Pk> for SortedMultiVec<Pk, Ctx> {
+impl<Pk: Key, Ctx: Context> ForEachKey<Pk> for SortedMultiVec<Pk, Ctx> {
     fn for_each_key<'a, F: FnMut(&'a Pk) -> bool>(&'a self, pred: F) -> bool {
         self.pks.iter().all(pred)
     }
 }
 
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> SortedMultiVec<Pk, Ctx> {
+impl<Pk: Key, Ctx: Context> SortedMultiVec<Pk, Ctx> {
     /// utility function to sanity a sorted multi vec
     pub fn sanity_check(&self) -> Result<(), Error> {
         let ms: Miniscript<Pk, Ctx> =
@@ -115,7 +115,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> SortedMultiVec<Pk, Ctx> {
     }
 }
 
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> SortedMultiVec<Pk, Ctx> {
+impl<Pk: Key, Ctx: Context> SortedMultiVec<Pk, Ctx> {
     /// Create Terminal::Multi containing sorted pubkeys
     pub fn sorted_node(&self) -> Terminal<Pk, Ctx>
     where
@@ -193,7 +193,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> SortedMultiVec<Pk, Ctx> {
     }
 }
 
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> policy::Liftable<Pk> for SortedMultiVec<Pk, Ctx> {
+impl<Pk: Key, Ctx: Context> policy::Liftable<Pk> for SortedMultiVec<Pk, Ctx> {
     fn lift(&self) -> Result<policy::semantic::Policy<Pk>, Error> {
         let ret = policy::semantic::Policy::Threshold(
             self.k,
@@ -206,13 +206,13 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> policy::Liftable<Pk> for SortedMulti
     }
 }
 
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> fmt::Debug for SortedMultiVec<Pk, Ctx> {
+impl<Pk: Key, Ctx: Context> fmt::Debug for SortedMultiVec<Pk, Ctx> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         fmt::Display::fmt(self, f)
     }
 }
 
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> fmt::Display for SortedMultiVec<Pk, Ctx> {
+impl<Pk: Key, Ctx: Context> fmt::Display for SortedMultiVec<Pk, Ctx> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "sortedmulti({}", self.k)?;
         for k in &self.pks {
diff --git a/src/descriptor/tr.rs b/src/descriptor/tr.rs
index 23c1742d0..1b2039462 100644
--- a/src/descriptor/tr.rs
+++ b/src/descriptor/tr.rs
@@ -18,15 +18,15 @@ use crate::policy::Liftable;
 use crate::prelude::*;
 use crate::util::{varint_len, witness_size};
 use crate::{
-    errstr, Error, ForEachKey, MiniscriptKey, Satisfier, ScriptContext, Tap, ToPublicKey,
-    TranslateErr, TranslatePk, Translator,
+    errstr, Context, Error, ForEachKey, Key, Satisfier, Tap, ToPublicKey, TranslateErr,
+    TranslatePk, Translator,
 };
 
 /// A Taproot Tree representation.
 // Hidden leaves are not yet supported in descriptor spec. Conceptually, it should
 // be simple to integrate those here, but it is best to wait on core for the exact syntax.
 #[derive(Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
-pub enum TapTree<Pk: MiniscriptKey> {
+pub enum TapTree<Pk: Key> {
     /// A taproot tree structure
     Tree {
         /// Left tree branch.
@@ -44,7 +44,7 @@ pub enum TapTree<Pk: MiniscriptKey> {
 }
 
 /// A taproot descriptor
-pub struct Tr<Pk: MiniscriptKey> {
+pub struct Tr<Pk: Key> {
     /// A taproot internal key
     internal_key: Pk,
     /// Optional Taproot Tree with spending conditions
@@ -59,7 +59,7 @@ pub struct Tr<Pk: MiniscriptKey> {
     spend_info: Mutex<Option<Arc<TaprootSpendInfo>>>,
 }
 
-impl<Pk: MiniscriptKey> Clone for Tr<Pk> {
+impl<Pk: Key> Clone for Tr<Pk> {
     fn clone(&self) -> Self {
         // When cloning, construct a new Mutex so that distinct clones don't
         // cause blocking between each other. We clone only the internal `Arc`,
@@ -78,15 +78,15 @@ impl<Pk: MiniscriptKey> Clone for Tr<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey> PartialEq for Tr<Pk> {
+impl<Pk: Key> PartialEq for Tr<Pk> {
     fn eq(&self, other: &Self) -> bool {
         self.internal_key == other.internal_key && self.tree == other.tree
     }
 }
 
-impl<Pk: MiniscriptKey> Eq for Tr<Pk> {}
+impl<Pk: Key> Eq for Tr<Pk> {}
 
-impl<Pk: MiniscriptKey> PartialOrd for Tr<Pk> {
+impl<Pk: Key> PartialOrd for Tr<Pk> {
     fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
         match self.internal_key.partial_cmp(&other.internal_key) {
             Some(cmp::Ordering::Equal) => {}
@@ -96,7 +96,7 @@ impl<Pk: MiniscriptKey> PartialOrd for Tr<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey> Ord for Tr<Pk> {
+impl<Pk: Key> Ord for Tr<Pk> {
     fn cmp(&self, other: &Self) -> cmp::Ordering {
         match self.internal_key.cmp(&other.internal_key) {
             cmp::Ordering::Equal => {}
@@ -106,14 +106,14 @@ impl<Pk: MiniscriptKey> Ord for Tr<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey> hash::Hash for Tr<Pk> {
+impl<Pk: Key> hash::Hash for Tr<Pk> {
     fn hash<H: hash::Hasher>(&self, state: &mut H) {
         self.internal_key.hash(state);
         self.tree.hash(state);
     }
 }
 
-impl<Pk: MiniscriptKey> TapTree<Pk> {
+impl<Pk: Key> TapTree<Pk> {
     /// Creates a `TapTree` by combining `left` and `right` tree nodes.
     pub(crate) fn combine(left: TapTree<Pk>, right: TapTree<Pk>) -> Self {
         let height = 1 + cmp::max(left.height(), right.height());
@@ -148,7 +148,7 @@ impl<Pk: MiniscriptKey> TapTree<Pk> {
     fn translate_helper<T, Q, E>(&self, t: &mut T) -> Result<TapTree<Q>, TranslateErr<E>>
     where
         T: Translator<Pk, Q, E>,
-        Q: MiniscriptKey,
+        Q: Key,
     {
         let frag = match *self {
             TapTree::Tree {
@@ -166,7 +166,7 @@ impl<Pk: MiniscriptKey> TapTree<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey> fmt::Display for TapTree<Pk> {
+impl<Pk: Key> fmt::Display for TapTree<Pk> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             TapTree::Tree {
@@ -179,7 +179,7 @@ impl<Pk: MiniscriptKey> fmt::Display for TapTree<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey> fmt::Debug for TapTree<Pk> {
+impl<Pk: Key> fmt::Debug for TapTree<Pk> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
             TapTree::Tree {
@@ -192,7 +192,7 @@ impl<Pk: MiniscriptKey> fmt::Debug for TapTree<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey> Tr<Pk> {
+impl<Pk: Key> Tr<Pk> {
     /// Create a new [`Tr`] descriptor from internal key and [`TapTree`]
     pub fn new(internal_key: Pk, tree: Option<TapTree<Pk>>) -> Result<Self, Error> {
         Tap::check_pk(&internal_key)?;
@@ -378,7 +378,7 @@ impl<Pk: MiniscriptKey> Tr<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey + ToPublicKey> Tr<Pk> {
+impl<Pk: Key + ToPublicKey> Tr<Pk> {
     /// Obtains the corresponding script pubkey for this descriptor.
     pub fn script_pubkey(&self) -> ScriptBuf {
         let output_key = self.spend_info().output_key();
@@ -429,13 +429,13 @@ impl<Pk: MiniscriptKey + ToPublicKey> Tr<Pk> {
 /// would yield (2, A), (2, B), (2,C), (3, D), (3, E).
 ///
 #[derive(Debug, Clone)]
-pub struct TapTreeIter<'a, Pk: MiniscriptKey> {
+pub struct TapTreeIter<'a, Pk: Key> {
     stack: Vec<(u8, &'a TapTree<Pk>)>,
 }
 
 impl<'a, Pk> Iterator for TapTreeIter<'a, Pk>
 where
-    Pk: MiniscriptKey + 'a,
+    Pk: Key + 'a,
 {
     type Item = (u8, &'a Miniscript<Pk, Tap>);
 
@@ -533,7 +533,7 @@ impl_from_str!(
     }
 );
 
-impl<Pk: MiniscriptKey> fmt::Debug for Tr<Pk> {
+impl<Pk: Key> fmt::Debug for Tr<Pk> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self.tree {
             Some(ref s) => write!(f, "tr({:?},{:?})", self.internal_key, s),
@@ -542,7 +542,7 @@ impl<Pk: MiniscriptKey> fmt::Debug for Tr<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey> fmt::Display for Tr<Pk> {
+impl<Pk: Key> fmt::Display for Tr<Pk> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         use fmt::Write;
         let mut wrapped_f = checksum::Formatter::new(f);
@@ -625,9 +625,9 @@ fn split_once(inp: &str, delim: char) -> Option<(&str, &str)> {
     }
 }
 
-impl<Pk: MiniscriptKey> Liftable<Pk> for TapTree<Pk> {
+impl<Pk: Key> Liftable<Pk> for TapTree<Pk> {
     fn lift(&self) -> Result<Policy<Pk>, Error> {
-        fn lift_helper<Pk: MiniscriptKey>(s: &TapTree<Pk>) -> Result<Policy<Pk>, Error> {
+        fn lift_helper<Pk: Key>(s: &TapTree<Pk>) -> Result<Policy<Pk>, Error> {
             match *s {
                 TapTree::Tree {
                     ref left,
@@ -646,7 +646,7 @@ impl<Pk: MiniscriptKey> Liftable<Pk> for TapTree<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey> Liftable<Pk> for Tr<Pk> {
+impl<Pk: Key> Liftable<Pk> for Tr<Pk> {
     fn lift(&self) -> Result<Policy<Pk>, Error> {
         match &self.tree {
             Some(root) => Ok(Policy::Threshold(
@@ -658,7 +658,7 @@ impl<Pk: MiniscriptKey> Liftable<Pk> for Tr<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey> ForEachKey<Pk> for Tr<Pk> {
+impl<Pk: Key> ForEachKey<Pk> for Tr<Pk> {
     fn for_each_key<'a, F: FnMut(&'a Pk) -> bool>(&'a self, mut pred: F) -> bool {
         let script_keys_res = self
             .iter_scripts()
@@ -667,11 +667,7 @@ impl<Pk: MiniscriptKey> ForEachKey<Pk> for Tr<Pk> {
     }
 }
 
-impl<P, Q> TranslatePk<P, Q> for Tr<P>
-where
-    P: MiniscriptKey,
-    Q: MiniscriptKey,
-{
+impl<P: Key, Q: Key> TranslatePk<P, Q> for Tr<P> {
     type Output = Tr<Q>;
 
     fn translate_pk<T, E>(&self, translate: &mut T) -> Result<Self::Output, TranslateErr<E>>
diff --git a/src/interpreter/inner.rs b/src/interpreter/inner.rs
index 266670eaf..10c6a2cd3 100644
--- a/src/interpreter/inner.rs
+++ b/src/interpreter/inner.rs
@@ -6,7 +6,7 @@ use bitcoin::taproot::{ControlBlock, TAPROOT_ANNEX_PREFIX};
 use bitcoin::Witness;
 
 use super::{stack, BitcoinKey, Error, Stack};
-use crate::miniscript::context::{NoChecks, ScriptContext, SigType};
+use crate::miniscript::context::{Context, NoChecks, SigType};
 use crate::prelude::*;
 use crate::{BareCtx, ExtParams, Legacy, Miniscript, Segwitv0, Tap, ToPublicKey, Translator};
 
@@ -38,7 +38,7 @@ fn pk_from_stack_elem(
 
 // Parse the script with appropriate context to check for context errors like
 // correct usage of x-only keys or multi_a
-fn script_from_stack_elem<Ctx: ScriptContext>(
+fn script_from_stack_elem<Ctx: Context>(
     elem: &stack::Element<'_>,
 ) -> Result<Miniscript<Ctx::Key, Ctx>, Error> {
     match *elem {
@@ -368,7 +368,7 @@ pub(super) trait ToNoChecks {
     fn to_no_checks_ms(&self) -> Miniscript<BitcoinKey, NoChecks>;
 }
 
-impl<Ctx: ScriptContext> ToNoChecks for Miniscript<bitcoin::PublicKey, Ctx> {
+impl<Ctx: Context> ToNoChecks for Miniscript<bitcoin::PublicKey, Ctx> {
     fn to_no_checks_ms(&self) -> Miniscript<BitcoinKey, NoChecks> {
         struct TranslateFullPk;
 
@@ -385,7 +385,7 @@ impl<Ctx: ScriptContext> ToNoChecks for Miniscript<bitcoin::PublicKey, Ctx> {
     }
 }
 
-impl<Ctx: ScriptContext> ToNoChecks for Miniscript<bitcoin::key::XOnlyPublicKey, Ctx> {
+impl<Ctx: Context> ToNoChecks for Miniscript<bitcoin::key::XOnlyPublicKey, Ctx> {
     fn to_no_checks_ms(&self) -> Miniscript<BitcoinKey, NoChecks> {
         // specify the () error type as this cannot error
         struct TranslateXOnlyPk;
diff --git a/src/interpreter/mod.rs b/src/interpreter/mod.rs
index 37cd457fa..794b73cee 100644
--- a/src/interpreter/mod.rs
+++ b/src/interpreter/mod.rs
@@ -15,7 +15,7 @@ use bitcoin::hashes::{hash160, ripemd160, sha256, Hash};
 use bitcoin::{absolute, secp256k1, sighash, taproot, Sequence, TxOut, Witness};
 
 use crate::miniscript::context::{NoChecks, SigType};
-use crate::miniscript::ScriptContext;
+use crate::miniscript::Context;
 use crate::prelude::*;
 use crate::{hash256, Descriptor, Miniscript, Terminal, ToPublicKey};
 
@@ -26,7 +26,7 @@ mod stack;
 pub use self::error::Error;
 use self::error::PkEvalErrInner;
 use self::stack::Stack;
-use crate::MiniscriptKey;
+use crate::Key;
 
 /// An iterable Miniscript-structured representation of the spending of a coin
 pub struct Interpreter<'txin> {
@@ -72,15 +72,15 @@ impl KeySigPair {
 }
 
 // Internally used enum for different types of bitcoin keys
-// Even though we implement MiniscriptKey for BitcoinKey, we make sure that there
+// Even though we implement Key for BitcoinKey, we make sure that there
 // are little mis-use
 // - The only constructors for this are only called in from_txdata that take care
 //   using the correct enum variant
 // - This does not implement ToPublicKey to avoid context dependant encoding/decoding of 33/32
 //   byte keys. This allows us to keep a single NoChecks context instead of a context for
 //   for NoChecksSchnorr/NoChecksEcdsa.
-// Long term TODO: There really should be not be any need for Miniscript<Pk: MiniscriptKey> struct
-// to have the Pk: MiniscriptKey bound. The bound should be on all of it's methods. That would
+// Long term TODO: There really should be not be any need for Miniscript<Pk: Key> struct
+// to have the Pk: Key bound. The bound should be on all of it's methods. That would
 // require changing Miniscript struct to three generics Miniscript<Pk, Pkh, Ctx> and bound on
 // all of the methods of Miniscript to ensure that Pkh = Pk::Hash
 #[derive(Hash, Eq, Ord, PartialEq, PartialOrd, Clone, Copy, Debug)]
@@ -122,7 +122,7 @@ impl From<bitcoin::key::XOnlyPublicKey> for BitcoinKey {
     }
 }
 
-impl MiniscriptKey for BitcoinKey {
+impl Key for BitcoinKey {
     type Sha256 = sha256::Hash;
     type Hash256 = hash256::Hash;
     type Ripemd160 = ripemd160::Hash;
@@ -536,7 +536,7 @@ pub struct Iter<'intp, 'txin: 'intp> {
 ///Iterator for Iter
 impl<'intp, 'txin: 'intp> Iterator for Iter<'intp, 'txin>
 where
-    NoChecks: ScriptContext,
+    NoChecks: Context,
 {
     type Item = Result<SatisfiedConstraint, Error>;
 
@@ -556,7 +556,7 @@ where
 
 impl<'intp, 'txin: 'intp> Iter<'intp, 'txin>
 where
-    NoChecks: ScriptContext,
+    NoChecks: Context,
 {
     /// Helper function to push a NodeEvaluationState on state stack
     fn push_evaluation_state(
diff --git a/src/iter/mod.rs b/src/iter/mod.rs
index 02e59b6e2..46af5ab52 100644
--- a/src/iter/mod.rs
+++ b/src/iter/mod.rs
@@ -15,9 +15,9 @@ pub use tree::{
 };
 
 use crate::sync::Arc;
-use crate::{Miniscript, MiniscriptKey, ScriptContext, Terminal};
+use crate::{Context, Key, Miniscript, Terminal};
 
-impl<'a, Pk: MiniscriptKey, Ctx: ScriptContext> TreeLike for &'a Miniscript<Pk, Ctx> {
+impl<'a, Pk: Key, Ctx: Context> TreeLike for &'a Miniscript<Pk, Ctx> {
     fn as_node(&self) -> Tree<Self> {
         use Terminal::*;
         match self.node {
@@ -42,7 +42,7 @@ impl<'a, Pk: MiniscriptKey, Ctx: ScriptContext> TreeLike for &'a Miniscript<Pk,
     }
 }
 
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> TreeLike for Arc<Miniscript<Pk, Ctx>> {
+impl<Pk: Key, Ctx: Context> TreeLike for Arc<Miniscript<Pk, Ctx>> {
     fn as_node(&self) -> Tree<Self> {
         use Terminal::*;
         match self.node {
diff --git a/src/lib.rs b/src/lib.rs
index 707b496c5..1fa9d6cbe 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -140,18 +140,22 @@ use std::error;
 use bitcoin::blockdata::{opcodes, script};
 use bitcoin::hashes::{hash160, ripemd160, sha256, Hash};
 use bitcoin::locktime::absolute;
+/// `ScriptContext` alias to make usage of the library more ergonomic by reducing naming conflicts.
+pub use Context as ScriptContext;
+/// `MiniscriptKey` alias to make usage of the library more ergonomic by reducing naming conflicts.
+pub use Key as MiniscriptKey;
 
 pub use crate::descriptor::{DefiniteDescriptorKey, Descriptor, DescriptorPublicKey};
 pub use crate::interpreter::Interpreter;
 pub use crate::miniscript::analyzable::{AnalysisError, ExtParams};
-pub use crate::miniscript::context::{BareCtx, Legacy, ScriptContext, Segwitv0, SigType, Tap};
+pub use crate::miniscript::context::{BareCtx, Context, Legacy, Segwitv0, SigType, Tap};
 pub use crate::miniscript::decode::Terminal;
 pub use crate::miniscript::satisfy::{Preimage32, Satisfier};
 pub use crate::miniscript::{hash256, Miniscript};
 use crate::prelude::*;
 
 ///Public key trait which can be converted to Hash type
-pub trait MiniscriptKey: Clone + Eq + Ord + fmt::Debug + fmt::Display + hash::Hash {
+pub trait Key: Clone + Eq + Ord + fmt::Debug + fmt::Display + hash::Hash {
     /// Returns true if the pubkey is uncompressed. Defaults to `false`.
     fn is_uncompressed(&self) -> bool {
         false
@@ -170,31 +174,31 @@ pub trait MiniscriptKey: Clone + Eq + Ord + fmt::Debug + fmt::Display + hash::Ha
         0
     }
 
-    /// The associated [`bitcoin::hashes::sha256::Hash`] for this [`MiniscriptKey`], used in the
+    /// The associated [`bitcoin::hashes::sha256::Hash`] for this [`Key`], used in the
     /// sha256 fragment.
     type Sha256: Clone + Eq + Ord + fmt::Display + fmt::Debug + hash::Hash;
 
-    /// The associated [`miniscript::hash256::Hash`] for this [`MiniscriptKey`], used in the
+    /// The associated [`miniscript::hash256::Hash`] for this [`Key`], used in the
     /// hash256 fragment.
     type Hash256: Clone + Eq + Ord + fmt::Display + fmt::Debug + hash::Hash;
 
-    /// The associated [`bitcoin::hashes::ripemd160::Hash`] for this [`MiniscriptKey`] type, used
+    /// The associated [`bitcoin::hashes::ripemd160::Hash`] for this [`Key`] type, used
     /// in the ripemd160 fragment.
     type Ripemd160: Clone + Eq + Ord + fmt::Display + fmt::Debug + hash::Hash;
 
-    /// The associated [`bitcoin::hashes::hash160::Hash`] for this [`MiniscriptKey`] type, used in
+    /// The associated [`bitcoin::hashes::hash160::Hash`] for this [`Key`] type, used in
     /// the hash160 fragment.
     type Hash160: Clone + Eq + Ord + fmt::Display + fmt::Debug + hash::Hash;
 }
 
-impl MiniscriptKey for bitcoin::secp256k1::PublicKey {
+impl Key for bitcoin::secp256k1::PublicKey {
     type Sha256 = sha256::Hash;
     type Hash256 = hash256::Hash;
     type Ripemd160 = ripemd160::Hash;
     type Hash160 = hash160::Hash;
 }
 
-impl MiniscriptKey for bitcoin::PublicKey {
+impl Key for bitcoin::PublicKey {
     /// Returns the compressed-ness of the underlying secp256k1 key.
     fn is_uncompressed(&self) -> bool {
         !self.compressed
@@ -206,7 +210,7 @@ impl MiniscriptKey for bitcoin::PublicKey {
     type Hash160 = hash160::Hash;
 }
 
-impl MiniscriptKey for bitcoin::secp256k1::XOnlyPublicKey {
+impl Key for bitcoin::secp256k1::XOnlyPublicKey {
     type Sha256 = sha256::Hash;
     type Hash256 = hash256::Hash;
     type Ripemd160 = ripemd160::Hash;
@@ -217,7 +221,7 @@ impl MiniscriptKey for bitcoin::secp256k1::XOnlyPublicKey {
     }
 }
 
-impl MiniscriptKey for String {
+impl Key for String {
     type Sha256 = String; // specify hashes as string
     type Hash256 = String;
     type Ripemd160 = String;
@@ -225,7 +229,7 @@ impl MiniscriptKey for String {
 }
 
 /// Trait describing public key types which can be converted to bitcoin pubkeys
-pub trait ToPublicKey: MiniscriptKey {
+pub trait ToPublicKey: Key {
     /// Converts an object to a public key
     fn to_public_key(&self) -> bitcoin::PublicKey;
 
@@ -235,7 +239,7 @@ pub trait ToPublicKey: MiniscriptKey {
         bitcoin::secp256k1::XOnlyPublicKey::from(pk.inner)
     }
 
-    /// Obtain the public key hash for this MiniscriptKey
+    /// Obtain the public key hash for this Key
     /// Expects an argument to specify the signature type.
     /// This would determine whether to serialize the key as 32 byte x-only pubkey
     /// or regular public key when computing the hash160
@@ -246,17 +250,17 @@ pub trait ToPublicKey: MiniscriptKey {
         }
     }
 
-    /// Converts the generic associated [`MiniscriptKey::Sha256`] to [`sha256::Hash`]
-    fn to_sha256(hash: &<Self as MiniscriptKey>::Sha256) -> sha256::Hash;
+    /// Converts the generic associated [`Key::Sha256`] to [`sha256::Hash`]
+    fn to_sha256(hash: &<Self as Key>::Sha256) -> sha256::Hash;
 
-    /// Converts the generic associated [`MiniscriptKey::Hash256`] to [`hash256::Hash`]
-    fn to_hash256(hash: &<Self as MiniscriptKey>::Hash256) -> hash256::Hash;
+    /// Converts the generic associated [`Key::Hash256`] to [`hash256::Hash`]
+    fn to_hash256(hash: &<Self as Key>::Hash256) -> hash256::Hash;
 
-    /// Converts the generic associated [`MiniscriptKey::Ripemd160`] to [`ripemd160::Hash`]
-    fn to_ripemd160(hash: &<Self as MiniscriptKey>::Ripemd160) -> ripemd160::Hash;
+    /// Converts the generic associated [`Key::Ripemd160`] to [`ripemd160::Hash`]
+    fn to_ripemd160(hash: &<Self as Key>::Ripemd160) -> ripemd160::Hash;
 
-    /// Converts the generic associated [`MiniscriptKey::Hash160`] to [`hash160::Hash`]
-    fn to_hash160(hash: &<Self as MiniscriptKey>::Hash160) -> hash160::Hash;
+    /// Converts the generic associated [`Key::Hash160`] to [`hash160::Hash`]
+    fn to_hash160(hash: &<Self as Key>::Hash160) -> hash160::Hash;
 }
 
 impl ToPublicKey for bitcoin::PublicKey {
@@ -338,8 +342,8 @@ impl ToPublicKey for bitcoin::secp256k1::XOnlyPublicKey {
 /// associated with the other key. Used by the [`TranslatePk`] trait to do the actual translations.
 pub trait Translator<P, Q, E>
 where
-    P: MiniscriptKey,
-    Q: MiniscriptKey,
+    P: Key,
+    Q: Key,
 {
     /// Translates public keys P -> Q.
     fn pk(&mut self, pk: &P) -> Result<Q, E>;
@@ -410,11 +414,7 @@ impl<E: fmt::Debug> fmt::Debug for TranslateErr<E> {
 
 /// Converts a descriptor using abstract keys to one using specific keys. Uses translator `t` to do
 /// the actual translation function calls.
-pub trait TranslatePk<P, Q>
-where
-    P: MiniscriptKey,
-    Q: MiniscriptKey,
-{
+pub trait TranslatePk<P: Key, Q: Key> {
     /// The associated output type. This must be `Self<Q>`.
     type Output;
 
@@ -426,9 +426,9 @@ where
 }
 
 /// Either a key or keyhash, but both contain Pk
-// pub struct ForEach<'a, Pk: MiniscriptKey>(&'a Pk);
+// pub struct ForEach<'a, Pk: Key>(&'a Pk);
 
-// impl<'a, Pk: MiniscriptKey<Hash = Pk>> ForEach<'a, Pk> {
+// impl<'a, Pk: Key<Hash = Pk>> ForEach<'a, Pk> {
 //     /// Convenience method to avoid distinguishing between keys and hashes when these are the same type
 //     pub fn as_key(&self) -> &'a Pk {
 //         self.0
@@ -436,7 +436,7 @@ where
 // }
 
 /// Trait describing the ability to iterate over every key
-pub trait ForEachKey<Pk: MiniscriptKey> {
+pub trait ForEachKey<Pk: Key> {
     /// Run a predicate on every key in the descriptor, returning whether
     /// the predicate returned true for every key
     fn for_each_key<'a, F: FnMut(&'a Pk) -> bool>(&'a self, pred: F) -> bool
@@ -520,7 +520,7 @@ pub enum Error {
     /// Errors related to lifting
     LiftError(policy::LiftError),
     /// Forward script context related errors
-    ContextError(miniscript::context::ScriptContextError),
+    ContextError(miniscript::context::ContextError),
     /// Recursion depth exceeded when parsing policy/miniscript from string
     MaxRecursiveDepthExceeded,
     /// Script size too large
@@ -681,8 +681,8 @@ impl error::Error for Error {
 #[doc(hidden)]
 impl<Pk, Ctx> From<miniscript::types::Error<Pk, Ctx>> for Error
 where
-    Pk: MiniscriptKey,
-    Ctx: ScriptContext,
+    Pk: Key,
+    Ctx: Context,
 {
     fn from(e: miniscript::types::Error<Pk, Ctx>) -> Error {
         Error::TypeCheck(e.to_string())
@@ -697,8 +697,8 @@ impl From<policy::LiftError> for Error {
 }
 
 #[doc(hidden)]
-impl From<miniscript::context::ScriptContextError> for Error {
-    fn from(e: miniscript::context::ScriptContextError) -> Error {
+impl From<miniscript::context::ContextError> for Error {
+    fn from(e: miniscript::context::ContextError) -> Error {
         Error::ContextError(e)
     }
 }
diff --git a/src/macros.rs b/src/macros.rs
index 6d4b9156b..115aac32a 100644
--- a/src/macros.rs
+++ b/src/macros.rs
@@ -28,16 +28,16 @@ macro_rules! impl_from_tree {
     ) => {
         impl<Pk $(, $gen)*> $crate::expression::FromTree for $name
         where
-            Pk: MiniscriptKey + core::str::FromStr,
+            Pk: Key + core::str::FromStr,
             Pk::Sha256: core::str::FromStr,
             Pk::Hash256: core::str::FromStr,
             Pk::Ripemd160: core::str::FromStr,
             Pk::Hash160: core::str::FromStr,
             <Pk as core::str::FromStr>::Err: $crate::prelude::ToString,
-            <<Pk as MiniscriptKey>::Sha256 as core::str::FromStr>::Err: $crate::prelude::ToString,
-            <<Pk as MiniscriptKey>::Hash256 as core::str::FromStr>::Err: $crate::prelude::ToString,
-            <<Pk as MiniscriptKey>::Ripemd160 as core::str::FromStr>::Err: $crate::prelude::ToString,
-            <<Pk as MiniscriptKey>::Hash160 as core::str::FromStr>::Err: $crate::prelude::ToString,
+            <<Pk as Key>::Sha256 as core::str::FromStr>::Err: $crate::prelude::ToString,
+            <<Pk as Key>::Hash256 as core::str::FromStr>::Err: $crate::prelude::ToString,
+            <<Pk as Key>::Ripemd160 as core::str::FromStr>::Err: $crate::prelude::ToString,
+            <<Pk as Key>::Hash160 as core::str::FromStr>::Err: $crate::prelude::ToString,
             $($gen : $gen_con,)*
             {
 
@@ -60,16 +60,16 @@ macro_rules! impl_from_str {
     ) => {
         impl<Pk $(, $gen)*> core::str::FromStr for $name
         where
-            Pk: MiniscriptKey + core::str::FromStr,
+            Pk: Key + core::str::FromStr,
             Pk::Sha256: core::str::FromStr,
             Pk::Hash256: core::str::FromStr,
             Pk::Ripemd160: core::str::FromStr,
             Pk::Hash160: core::str::FromStr,
             <Pk as core::str::FromStr>::Err: $crate::prelude::ToString,
-            <<Pk as MiniscriptKey>::Sha256 as core::str::FromStr>::Err: $crate::prelude::ToString,
-            <<Pk as MiniscriptKey>::Hash256 as core::str::FromStr>::Err: $crate::prelude::ToString,
-            <<Pk as MiniscriptKey>::Ripemd160 as core::str::FromStr>::Err: $crate::prelude::ToString,
-            <<Pk as MiniscriptKey>::Hash160 as core::str::FromStr>::Err: $crate::prelude::ToString,
+            <<Pk as Key>::Sha256 as core::str::FromStr>::Err: $crate::prelude::ToString,
+            <<Pk as Key>::Hash256 as core::str::FromStr>::Err: $crate::prelude::ToString,
+            <<Pk as Key>::Ripemd160 as core::str::FromStr>::Err: $crate::prelude::ToString,
+            <<Pk as Key>::Hash160 as core::str::FromStr>::Err: $crate::prelude::ToString,
             $($gen : $gen_con,)*
             {
                 type Err = $err_ty;
@@ -92,16 +92,16 @@ macro_rules! impl_block_str {
     ) => {
         impl<Pk $(, $gen)*> $name
         where
-            Pk: MiniscriptKey + core::str::FromStr,
+            Pk: Key + core::str::FromStr,
             Pk::Sha256: core::str::FromStr,
             Pk::Hash256: core::str::FromStr,
             Pk::Ripemd160: core::str::FromStr,
             Pk::Hash160: core::str::FromStr,
             <Pk as core::str::FromStr>::Err: $crate::prelude::ToString,
-            <<Pk as MiniscriptKey>::Sha256 as core::str::FromStr>::Err: $crate::prelude::ToString,
-            <<Pk as MiniscriptKey>::Hash256 as core::str::FromStr>::Err: $crate::prelude::ToString,
-            <<Pk as MiniscriptKey>::Ripemd160 as core::str::FromStr>::Err: $crate::prelude::ToString,
-            <<Pk as MiniscriptKey>::Hash160 as core::str::FromStr>::Err: $crate::prelude::ToString,
+            <<Pk as Key>::Sha256 as core::str::FromStr>::Err: $crate::prelude::ToString,
+            <<Pk as Key>::Hash256 as core::str::FromStr>::Err: $crate::prelude::ToString,
+            <<Pk as Key>::Ripemd160 as core::str::FromStr>::Err: $crate::prelude::ToString,
+            <<Pk as Key>::Hash160 as core::str::FromStr>::Err: $crate::prelude::ToString,
             $($gen : $gen_con,)*
             {
                 $(#[$meta])*
@@ -119,19 +119,19 @@ macro_rules! serde_string_impl_pk {
         #[cfg(feature = "serde")]
         impl<'de, Pk $(, $gen)*> $crate::serde::Deserialize<'de> for $name<Pk $(, $gen)*>
         where
-            Pk: $crate::MiniscriptKey + core::str::FromStr,
+            Pk: $crate::Key + core::str::FromStr,
             Pk::Sha256: core::str::FromStr,
             Pk::Hash256: core::str::FromStr,
             Pk::Ripemd160: core::str::FromStr,
             Pk::Hash160: core::str::FromStr,
             <Pk as core::str::FromStr>::Err: core::fmt::Display,
-            <<Pk as $crate::MiniscriptKey>::Sha256 as core::str::FromStr>::Err:
+            <<Pk as $crate::Key>::Sha256 as core::str::FromStr>::Err:
                 core::fmt::Display,
-            <<Pk as $crate::MiniscriptKey>::Hash256 as core::str::FromStr>::Err:
+            <<Pk as $crate::Key>::Hash256 as core::str::FromStr>::Err:
                 core::fmt::Display,
-            <<Pk as $crate::MiniscriptKey>::Ripemd160 as core::str::FromStr>::Err:
+            <<Pk as $crate::Key>::Ripemd160 as core::str::FromStr>::Err:
                 core::fmt::Display,
-            <<Pk as $crate::MiniscriptKey>::Hash160 as core::str::FromStr>::Err:
+            <<Pk as $crate::Key>::Hash160 as core::str::FromStr>::Err:
                 core::fmt::Display,
             $($gen : $gen_con,)*
         {
@@ -147,19 +147,19 @@ macro_rules! serde_string_impl_pk {
                 struct Visitor<Pk $(, $gen)*>(PhantomData<(Pk $(, $gen)*)>);
                 impl<'de, Pk $(, $gen)*> $crate::serde::de::Visitor<'de> for Visitor<Pk $(, $gen)*>
                 where
-                    Pk: $crate::MiniscriptKey + core::str::FromStr,
+                    Pk: $crate::Key + core::str::FromStr,
                     Pk::Sha256: core::str::FromStr,
                     Pk::Hash256: core::str::FromStr,
                     Pk::Ripemd160: core::str::FromStr,
                     Pk::Hash160: core::str::FromStr,
                     <Pk as core::str::FromStr>::Err: core::fmt::Display,
-                    <<Pk as $crate::MiniscriptKey>::Sha256 as core::str::FromStr>::Err:
+                    <<Pk as $crate::Key>::Sha256 as core::str::FromStr>::Err:
                         core::fmt::Display,
-                    <<Pk as $crate::MiniscriptKey>::Hash256 as core::str::FromStr>::Err:
+                    <<Pk as $crate::Key>::Hash256 as core::str::FromStr>::Err:
                         core::fmt::Display,
-                    <<Pk as $crate::MiniscriptKey>::Ripemd160 as core::str::FromStr>::Err:
+                    <<Pk as $crate::Key>::Ripemd160 as core::str::FromStr>::Err:
                         core::fmt::Display,
-                    <<Pk as $crate::MiniscriptKey>::Hash160 as core::str::FromStr>::Err:
+                    <<Pk as $crate::Key>::Hash160 as core::str::FromStr>::Err:
                         core::fmt::Display,
                     $($gen: $gen_con,)*
                 {
@@ -198,7 +198,7 @@ macro_rules! serde_string_impl_pk {
         #[cfg(feature = "serde")]
         impl<'de, Pk $(, $gen)*> $crate::serde::Serialize for $name<Pk $(, $gen)*>
         where
-            Pk: $crate::MiniscriptKey,
+            Pk: $crate::Key,
             $($gen: $gen_con,)*
         {
             fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
diff --git a/src/miniscript/analyzable.rs b/src/miniscript/analyzable.rs
index 4c30e7df9..f2bbe3f73 100644
--- a/src/miniscript/analyzable.rs
+++ b/src/miniscript/analyzable.rs
@@ -10,7 +10,7 @@ use core::fmt;
 use std::error;
 
 use crate::prelude::*;
-use crate::{Miniscript, MiniscriptKey, ScriptContext, Terminal};
+use crate::{Context, Key, Miniscript, Terminal};
 
 /// Params for parsing miniscripts that either non-sane or non-specified(experimental) in the spec.
 /// Used as a parameter [`Miniscript::from_str_ext`] and [`Miniscript::parse_with_ext`].
@@ -184,7 +184,7 @@ impl error::Error for AnalysisError {
     }
 }
 
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
+impl<Pk: Key, Ctx: Context> Miniscript<Pk, Ctx> {
     /// Whether all spend paths of miniscript require a signature
     pub fn requires_sig(&self) -> bool {
         self.ty.mall.safe
diff --git a/src/miniscript/astelem.rs b/src/miniscript/astelem.rs
index c7d403679..315a2e22a 100644
--- a/src/miniscript/astelem.rs
+++ b/src/miniscript/astelem.rs
@@ -16,14 +16,12 @@ use sync::Arc;
 
 use crate::miniscript::context::SigType;
 use crate::miniscript::types::{self, Property};
-use crate::miniscript::ScriptContext;
+use crate::miniscript::Context;
 use crate::prelude::*;
 use crate::util::MsKeyBuilder;
-use crate::{
-    errstr, expression, AbsLockTime, Error, Miniscript, MiniscriptKey, Terminal, ToPublicKey,
-};
+use crate::{errstr, expression, AbsLockTime, Error, Key, Miniscript, Terminal, ToPublicKey};
 
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
+impl<Pk: Key, Ctx: Context> Terminal<Pk, Ctx> {
     /// Internal helper function for displaying wrapper types; returns
     /// a character to display before the `:` as well as a reference
     /// to the wrapped type to allow easy recursion
@@ -44,7 +42,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
     }
 }
 
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> fmt::Debug for Terminal<Pk, Ctx> {
+impl<Pk: Key, Ctx: Context> fmt::Debug for Terminal<Pk, Ctx> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         f.write_str("[")?;
         if let Ok(type_map) = types::Type::type_check(self, |_| None) {
@@ -142,7 +140,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> fmt::Debug for Terminal<Pk, Ctx> {
     }
 }
 
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> fmt::Display for Terminal<Pk, Ctx> {
+impl<Pk: Key, Ctx: Context> fmt::Display for Terminal<Pk, Ctx> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             Terminal::PkK(ref pk) => write!(f, "pk_k({})", pk),
@@ -242,7 +240,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> fmt::Display for Terminal<Pk, Ctx> {
 }
 
 impl_from_tree!(
-    ;Ctx; ScriptContext,
+    ;Ctx; Context,
     Arc<Terminal<Pk, Ctx>>,
     fn from_tree(top: &expression::Tree) -> Result<Arc<Terminal<Pk, Ctx>>, Error> {
         Ok(Arc::new(expression::FromTree::from_tree(top)?))
@@ -250,7 +248,7 @@ impl_from_tree!(
 );
 
 impl_from_tree!(
-    ;Ctx; ScriptContext,
+    ;Ctx; Context,
     Terminal<Pk, Ctx>,
     fn from_tree(top: &expression::Tree) -> Result<Terminal<Pk, Ctx>, Error> {
         let mut aliased_wrap;
@@ -431,13 +429,13 @@ impl_from_tree!(
 );
 
 /// Helper trait to add a `push_astelem` method to `script::Builder`
-trait PushAstElem<Pk: MiniscriptKey, Ctx: ScriptContext> {
+trait PushAstElem<Pk: Key, Ctx: Context> {
     fn push_astelem(self, ast: &Miniscript<Pk, Ctx>) -> Self
     where
         Pk: ToPublicKey;
 }
 
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> PushAstElem<Pk, Ctx> for script::Builder {
+impl<Pk: Key, Ctx: Context> PushAstElem<Pk, Ctx> for script::Builder {
     fn push_astelem(self, ast: &Miniscript<Pk, Ctx>) -> Self
     where
         Pk: ToPublicKey,
@@ -446,7 +444,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> PushAstElem<Pk, Ctx> for script::Bui
     }
 }
 
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
+impl<Pk: Key, Ctx: Context> Terminal<Pk, Ctx> {
     /// Encode the element as a fragment of Bitcoin Script. The inverse
     /// function, from Script to an AST element, is implemented in the
     /// `parse` module.
diff --git a/src/miniscript/context.rs b/src/miniscript/context.rs
index f3563b83c..a37e074bf 100644
--- a/src/miniscript/context.rs
+++ b/src/miniscript/context.rs
@@ -7,6 +7,8 @@ use std::error;
 
 use bitcoin::constants::MAX_BLOCK_WEIGHT;
 use bitcoin::hashes::{hash160, ripemd160, sha256};
+/// `ScriptContextError` alias for backwards compatability and to reduce potential naming conflicts.
+pub use ContextError as ScriptContextError;
 
 use super::decode::ParseableKey;
 use crate::miniscript::limits::{
@@ -17,11 +19,11 @@ use crate::miniscript::limits::{
 use crate::miniscript::types;
 use crate::prelude::*;
 use crate::util::witness_to_scriptsig;
-use crate::{hash256, Error, ForEachKey, Miniscript, MiniscriptKey, Terminal};
+use crate::{hash256, Error, ForEachKey, Key, Miniscript, Terminal};
 
 /// Error for Script Context
 #[derive(Clone, PartialEq, Eq, Debug)]
-pub enum ScriptContextError {
+pub enum ContextError {
     /// Script Context does not permit PkH for non-malleability
     /// It is not possible to estimate the pubkey size at the creation
     /// time because of uncompressed pubkeys
@@ -68,9 +70,9 @@ pub enum ScriptContextError {
 }
 
 #[cfg(feature = "std")]
-impl error::Error for ScriptContextError {
+impl error::Error for ContextError {
     fn cause(&self) -> Option<&dyn error::Error> {
-        use self::ScriptContextError::*;
+        use self::ContextError::*;
 
         match self {
             MalleablePkH
@@ -93,100 +95,100 @@ impl error::Error for ScriptContextError {
     }
 }
 
-impl fmt::Display for ScriptContextError {
+impl fmt::Display for ContextError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
-            ScriptContextError::MalleablePkH => write!(f, "PkH is malleable under Legacy rules"),
-            ScriptContextError::MalleableOrI => write!(f, "OrI is malleable under Legacy rules"),
-            ScriptContextError::MalleableDupIf => {
+            ContextError::MalleablePkH => write!(f, "PkH is malleable under Legacy rules"),
+            ContextError::MalleableOrI => write!(f, "OrI is malleable under Legacy rules"),
+            ContextError::MalleableDupIf => {
                 write!(f, "DupIf is malleable under Legacy rules")
             }
-            ScriptContextError::CompressedOnly(ref pk) => {
+            ContextError::CompressedOnly(ref pk) => {
                 write!(
                     f,
                     "Only Compressed pubkeys are allowed in segwit context. Found {}",
                     pk
                 )
             }
-            ScriptContextError::XOnlyKeysNotAllowed(ref pk, ref ctx) => {
+            ContextError::XOnlyKeysNotAllowed(ref pk, ref ctx) => {
                 write!(f, "x-only key {} not allowed in {}", pk, ctx)
             }
-            ScriptContextError::UncompressedKeysNotAllowed => {
+            ContextError::UncompressedKeysNotAllowed => {
                 write!(
                     f,
                     "uncompressed keys cannot be used in Taproot descriptors."
                 )
             }
-            ScriptContextError::MaxWitnessItemssExceeded { actual, limit } => write!(
+            ContextError::MaxWitnessItemssExceeded { actual, limit } => write!(
                 f,
                 "At least one spending path in the Miniscript fragment has {} more \
                  witness items than limit {}.",
                 actual, limit
             ),
-            ScriptContextError::MaxOpCountExceeded => write!(
+            ContextError::MaxOpCountExceeded => write!(
                 f,
                 "At least one satisfaction path in the Miniscript fragment contains \
                  more than MAX_OPS_PER_SCRIPT opcodes."
             ),
-            ScriptContextError::MaxWitnessScriptSizeExceeded => write!(
+            ContextError::MaxWitnessScriptSizeExceeded => write!(
                 f,
                 "The Miniscript corresponding Script would be larger than \
                     MAX_STANDARD_P2WSH_SCRIPT_SIZE bytes."
             ),
-            ScriptContextError::MaxRedeemScriptSizeExceeded => write!(
+            ContextError::MaxRedeemScriptSizeExceeded => write!(
                 f,
                 "The Miniscript corresponding Script would be larger than \
                 MAX_SCRIPT_ELEMENT_SIZE bytes."
             ),
-            ScriptContextError::MaxScriptSigSizeExceeded => write!(
+            ContextError::MaxScriptSigSizeExceeded => write!(
                 f,
                 "At least one satisfaction in Miniscript would be larger than \
                 MAX_SCRIPTSIG_SIZE scriptsig"
             ),
-            ScriptContextError::ImpossibleSatisfaction => {
+            ContextError::ImpossibleSatisfaction => {
                 write!(
                     f,
                     "Impossible to satisfy Miniscript under the current context"
                 )
             }
-            ScriptContextError::TaprootMultiDisabled => {
+            ContextError::TaprootMultiDisabled => {
                 write!(f, "Invalid use of Multi node in taproot context")
             }
-            ScriptContextError::StackSizeLimitExceeded { actual, limit } => {
+            ContextError::StackSizeLimitExceeded { actual, limit } => {
                 write!(
                     f,
                     "Stack limit {} can exceed the allowed limit {} in at least one script path during script execution",
                     actual, limit
                 )
             }
-            ScriptContextError::CheckMultiSigLimitExceeded => {
+            ContextError::CheckMultiSigLimitExceeded => {
                 write!(
                     f,
                     "CHECkMULTISIG ('multi()' descriptor) only supports up to 20 pubkeys"
                 )
             }
-            ScriptContextError::MultiANotAllowed => {
+            ContextError::MultiANotAllowed => {
                 write!(f, "Multi a(CHECKSIGADD) only allowed post tapscript")
             }
         }
     }
 }
 
-/// The ScriptContext for Miniscript. Additional type information associated with
+/// The Context for Miniscript. Additional type information associated with
 /// miniscript that is used for carrying out checks that dependent on the
 /// context under which the script is used.
 /// For example, disallowing uncompressed keys in Segwit context
-pub trait ScriptContext:
+pub trait Context:
     fmt::Debug + Clone + Ord + PartialOrd + Eq + PartialEq + hash::Hash + private::Sealed
 where
-    Self::Key: MiniscriptKey<Sha256 = sha256::Hash>,
-    Self::Key: MiniscriptKey<Hash256 = hash256::Hash>,
-    Self::Key: MiniscriptKey<Ripemd160 = ripemd160::Hash>,
-    Self::Key: MiniscriptKey<Hash160 = hash160::Hash>,
+    Self::Key: Key<Sha256 = sha256::Hash>,
+    Self::Key: Key<Hash256 = hash256::Hash>,
+    Self::Key: Key<Ripemd160 = ripemd160::Hash>,
+    Self::Key: Key<Hash160 = hash160::Hash>,
 {
     /// The consensus key associated with the type. Must be a parseable key
     type Key: ParseableKey;
-    /// Depending on ScriptContext, fragments can be malleable. For Example,
+    /// Depending on Context, fragments can be malleable. For Example,
     /// under Legacy context, PkH is malleable because it is possible to
     /// estimate the cost of satisfaction because of compressed keys
     /// This is currently only used in compiler code for removing malleable
@@ -194,14 +196,14 @@ where
     /// This does NOT recursively check if the children of the fragment are
     /// valid or not. Since the compilation proceeds in a leaf to root fashion,
     /// a recursive check is unnecessary.
-    fn check_terminal_non_malleable<Pk: MiniscriptKey>(
+    fn check_terminal_non_malleable<Pk: Key>(
         _frag: &Terminal<Pk, Self>,
-    ) -> Result<(), ScriptContextError>;
+    ) -> Result<(), ContextError>;
 
-    /// Check whether the given satisfaction is valid under the ScriptContext
+    /// Check whether the given satisfaction is valid under the Context
     /// For example, segwit satisfactions may fail if the witness len is more
     /// 3600 or number of stack elements are more than 100.
-    fn check_witness<Pk: MiniscriptKey>(_witness: &[Vec<u8>]) -> Result<(), ScriptContextError> {
+    fn check_witness<Pk: Key>(_witness: &[Vec<u8>]) -> Result<(), ContextError> {
         // Only really need to do this for segwitv0 and legacy
         // Bare is already restrcited by standardness rules
         // and would reach these limits.
@@ -212,23 +214,23 @@ where
     /// Legacy/Bare does not allow x_only keys
     /// Segwit does not allow uncompressed keys and x_only keys
     /// Tapscript does not allow uncompressed keys
-    fn check_pk<Pk: MiniscriptKey>(pk: &Pk) -> Result<(), ScriptContextError>;
+    fn check_pk<Pk: Key>(pk: &Pk) -> Result<(), ContextError>;
 
     /// Depending on script context, the size of a satifaction witness may slightly differ.
-    fn max_satisfaction_size<Pk: MiniscriptKey>(ms: &Miniscript<Pk, Self>) -> Option<usize>;
+    fn max_satisfaction_size<Pk: Key>(ms: &Miniscript<Pk, Self>) -> Option<usize>;
     /// Depending on script Context, some of the Terminals might not
     /// be valid under the current consensus rules.
     /// Or some of the script resource limits may have been exceeded.
     /// These miniscripts would never be accepted by the Bitcoin network and hence
     /// it is safe to discard them
-    /// For example, in Segwit Context with MiniscriptKey as bitcoin::PublicKey
+    /// For example, in Segwit Context with Key as bitcoin::PublicKey
     /// uncompressed public keys are non-standard and thus invalid.
     /// In LegacyP2SH context, scripts above 520 bytes are invalid.
     /// Post Tapscript upgrade, this would have to consider other nodes.
     /// This does *NOT* recursively check the miniscript fragments.
-    fn check_global_consensus_validity<Pk: MiniscriptKey>(
+    fn check_global_consensus_validity<Pk: Key>(
         _ms: &Miniscript<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
+    ) -> Result<(), ContextError> {
         Ok(())
     }
 
@@ -236,13 +238,13 @@ where
     /// may have been exceeded under the current bitcoin core policy rules
     /// These miniscripts would never be accepted by the Bitcoin network and hence
     /// it is safe to discard them. (unless explicitly disabled by non-standard flag)
-    /// For example, in Segwit Context with MiniscriptKey as bitcoin::PublicKey
+    /// For example, in Segwit Context with Key as bitcoin::PublicKey
     /// scripts over 3600 bytes are invalid.
     /// Post Tapscript upgrade, this would have to consider other nodes.
     /// This does *NOT* recursively check the miniscript fragments.
-    fn check_global_policy_validity<Pk: MiniscriptKey>(
+    fn check_global_policy_validity<Pk: Key>(
         _ms: &Miniscript<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
+    ) -> Result<(), ContextError> {
         Ok(())
     }
 
@@ -250,9 +252,9 @@ where
     /// It is possible that some paths of miniscript may exceed resource limits
     /// and our current satisfier and lifting analysis would not work correctly.
     /// For example, satisfaction path(Legacy/Segwitv0) may require more than 201 opcodes.
-    fn check_local_consensus_validity<Pk: MiniscriptKey>(
+    fn check_local_consensus_validity<Pk: Key>(
         _ms: &Miniscript<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
+    ) -> Result<(), ContextError> {
         Ok(())
     }
 
@@ -261,17 +263,15 @@ where
     /// and our current satisfier and lifting analysis would not work correctly.
     /// For example, satisfaction path in Legacy context scriptSig more
     /// than 1650 bytes
-    fn check_local_policy_validity<Pk: MiniscriptKey>(
+    fn check_local_policy_validity<Pk: Key>(
         _ms: &Miniscript<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
+    ) -> Result<(), ContextError> {
         Ok(())
     }
 
     /// Check the consensus + policy(if not disabled) rules that are not based
     /// satisfaction
-    fn check_global_validity<Pk: MiniscriptKey>(
-        ms: &Miniscript<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
+    fn check_global_validity<Pk: Key>(ms: &Miniscript<Pk, Self>) -> Result<(), ContextError> {
         Self::check_global_consensus_validity(ms)?;
         Self::check_global_policy_validity(ms)?;
         Ok(())
@@ -279,9 +279,7 @@ where
 
     /// Check the consensus + policy(if not disabled) rules including the
     /// ones for satisfaction
-    fn check_local_validity<Pk: MiniscriptKey>(
-        ms: &Miniscript<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
+    fn check_local_validity<Pk: Key>(ms: &Miniscript<Pk, Self>) -> Result<(), ContextError> {
         Self::check_global_consensus_validity(ms)?;
         Self::check_global_policy_validity(ms)?;
         Self::check_local_consensus_validity(ms)?;
@@ -290,7 +288,7 @@ where
     }
 
     /// Check whether the top-level is type B
-    fn top_level_type_check<Pk: MiniscriptKey>(ms: &Miniscript<Pk, Self>) -> Result<(), Error> {
+    fn top_level_type_check<Pk: Key>(ms: &Miniscript<Pk, Self>) -> Result<(), Error> {
         if ms.ty.corr.base != types::Base::B {
             return Err(Error::NonTopLevel(format!("{:?}", ms)));
         }
@@ -328,7 +326,7 @@ where
     }
 
     /// Other top level checks that are context specific
-    fn other_top_level_checks<Pk: MiniscriptKey>(_ms: &Miniscript<Pk, Self>) -> Result<(), Error> {
+    fn other_top_level_checks<Pk: Key>(_ms: &Miniscript<Pk, Self>) -> Result<(), Error> {
         Ok(())
     }
 
@@ -341,7 +339,7 @@ where
     // that are only applicable at the top-level
     // We can also combine the top-level check for Base::B here
     // even though it does not depend on context, but helps in cleaner code
-    fn top_level_checks<Pk: MiniscriptKey>(ms: &Miniscript<Pk, Self>) -> Result<(), Error> {
+    fn top_level_checks<Pk: Key>(ms: &Miniscript<Pk, Self>) -> Result<(), Error> {
         Self::top_level_type_check(ms)?;
         Self::other_top_level_checks(ms)
     }
@@ -355,7 +353,7 @@ where
     /// Note that this includes the serialization prefix. Returns
     /// 34/66 for Bare/Legacy based on key compressedness
     /// 34 for Segwitv0, 33 for Tap
-    fn pk_len<Pk: MiniscriptKey>(pk: &Pk) -> usize;
+    fn pk_len<Pk: Key>(pk: &Pk) -> usize;
 
     /// Local helper function to display error messages with context
     fn name_str() -> &'static str;
@@ -370,31 +368,31 @@ pub enum SigType {
     Schnorr,
 }
 
-/// Legacy ScriptContext
+/// Legacy Context
 /// To be used as P2SH scripts
 /// For creation of Bare scriptpubkeys, construct the Miniscript
-/// under `Bare` ScriptContext
+/// under `Bare` Context
 #[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
 pub enum Legacy {}
 
-impl ScriptContext for Legacy {
+impl Context for Legacy {
     type Key = bitcoin::PublicKey;
-    fn check_terminal_non_malleable<Pk: MiniscriptKey>(
+    fn check_terminal_non_malleable<Pk: Key>(
         frag: &Terminal<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
+    ) -> Result<(), ContextError> {
         match *frag {
-            Terminal::PkH(ref _pkh) => Err(ScriptContextError::MalleablePkH),
-            Terminal::RawPkH(ref _pk) => Err(ScriptContextError::MalleablePkH),
-            Terminal::OrI(ref _a, ref _b) => Err(ScriptContextError::MalleableOrI),
-            Terminal::DupIf(ref _ms) => Err(ScriptContextError::MalleableDupIf),
+            Terminal::PkH(ref _pkh) => Err(ContextError::MalleablePkH),
+            Terminal::RawPkH(ref _pk) => Err(ContextError::MalleablePkH),
+            Terminal::OrI(ref _a, ref _b) => Err(ContextError::MalleableOrI),
+            Terminal::DupIf(ref _ms) => Err(ContextError::MalleableDupIf),
             _ => Ok(()),
         }
     }
 
     // Only compressed and uncompressed public keys are allowed in Legacy context
-    fn check_pk<Pk: MiniscriptKey>(pk: &Pk) -> Result<(), ScriptContextError> {
+    fn check_pk<Pk: Key>(pk: &Pk) -> Result<(), ContextError> {
         if pk.is_x_only_key() {
-            Err(ScriptContextError::XOnlyKeysNotAllowed(
+            Err(ContextError::XOnlyKeysNotAllowed(
                 pk.to_string(),
                 Self::name_str(),
             ))
@@ -403,71 +401,67 @@ impl ScriptContext for Legacy {
         }
     }
 
-    fn check_witness<Pk: MiniscriptKey>(witness: &[Vec<u8>]) -> Result<(), ScriptContextError> {
+    fn check_witness<Pk: Key>(witness: &[Vec<u8>]) -> Result<(), ContextError> {
         // In future, we could avoid by having a function to count only
         // len of script instead of converting it.
         if witness_to_scriptsig(witness).len() > MAX_SCRIPTSIG_SIZE {
-            return Err(ScriptContextError::MaxScriptSigSizeExceeded);
+            return Err(ContextError::MaxScriptSigSizeExceeded);
         }
         Ok(())
     }
 
-    fn check_global_consensus_validity<Pk: MiniscriptKey>(
+    fn check_global_consensus_validity<Pk: Key>(
         ms: &Miniscript<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
+    ) -> Result<(), ContextError> {
         if ms.ext.pk_cost > MAX_SCRIPT_ELEMENT_SIZE {
-            return Err(ScriptContextError::MaxRedeemScriptSizeExceeded);
+            return Err(ContextError::MaxRedeemScriptSizeExceeded);
         }
 
         match ms.node {
             Terminal::PkK(ref pk) => Self::check_pk(pk),
             Terminal::Multi(_k, ref pks) => {
                 if pks.len() > MAX_PUBKEYS_PER_MULTISIG {
-                    return Err(ScriptContextError::CheckMultiSigLimitExceeded);
+                    return Err(ContextError::CheckMultiSigLimitExceeded);
                 }
                 for pk in pks.iter() {
                     Self::check_pk(pk)?;
                 }
                 Ok(())
             }
-            Terminal::MultiA(..) => Err(ScriptContextError::MultiANotAllowed),
+            Terminal::MultiA(..) => Err(ContextError::MultiANotAllowed),
             _ => Ok(()),
         }
     }
 
-    fn check_local_consensus_validity<Pk: MiniscriptKey>(
+    fn check_local_consensus_validity<Pk: Key>(
         ms: &Miniscript<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
+    ) -> Result<(), ContextError> {
         match ms.ext.ops.op_count() {
-            None => Err(ScriptContextError::MaxOpCountExceeded),
+            None => Err(ContextError::MaxOpCountExceeded),
             Some(op_count) if op_count > MAX_OPS_PER_SCRIPT => {
-                Err(ScriptContextError::MaxOpCountExceeded)
+                Err(ContextError::MaxOpCountExceeded)
             }
             _ => Ok(()),
         }
     }
 
-    fn check_local_policy_validity<Pk: MiniscriptKey>(
-        ms: &Miniscript<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
+    fn check_local_policy_validity<Pk: Key>(ms: &Miniscript<Pk, Self>) -> Result<(), ContextError> {
         // Legacy scripts permit upto 1000 stack elements, 520 bytes consensus limits
         // on P2SH size, it is not possible to reach the 1000 elements limit and hence
         // we do not check it.
         match ms.max_satisfaction_size() {
-            Err(_e) => Err(ScriptContextError::ImpossibleSatisfaction),
-            Ok(size) if size > MAX_SCRIPTSIG_SIZE => {
-                Err(ScriptContextError::MaxScriptSigSizeExceeded)
-            }
+            Err(_e) => Err(ContextError::ImpossibleSatisfaction),
+            Ok(size) if size > MAX_SCRIPTSIG_SIZE => Err(ContextError::MaxScriptSigSizeExceeded),
             _ => Ok(()),
         }
     }
 
-    fn max_satisfaction_size<Pk: MiniscriptKey>(ms: &Miniscript<Pk, Self>) -> Option<usize> {
+    fn max_satisfaction_size<Pk: Key>(ms: &Miniscript<Pk, Self>) -> Option<usize> {
         // The scriptSig cost is the second element of the tuple
         ms.ext.max_sat_size.map(|x| x.1)
     }
 
-    fn pk_len<Pk: MiniscriptKey>(pk: &Pk) -> usize {
+    fn pk_len<Pk: Key>(pk: &Pk) -> usize {
         if pk.is_uncompressed() {
             66
         } else {
@@ -484,24 +478,24 @@ impl ScriptContext for Legacy {
     }
 }
 
-/// Segwitv0 ScriptContext
+/// Segwitv0 Context
 #[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
 pub enum Segwitv0 {}
 
-impl ScriptContext for Segwitv0 {
+impl Context for Segwitv0 {
     type Key = bitcoin::PublicKey;
-    fn check_terminal_non_malleable<Pk: MiniscriptKey>(
+    fn check_terminal_non_malleable<Pk: Key>(
         _frag: &Terminal<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
+    ) -> Result<(), ContextError> {
         Ok(())
     }
 
     // No x-only keys or uncompressed keys in Segwitv0 context
-    fn check_pk<Pk: MiniscriptKey>(pk: &Pk) -> Result<(), ScriptContextError> {
+    fn check_pk<Pk: Key>(pk: &Pk) -> Result<(), ContextError> {
         if pk.is_uncompressed() {
-            Err(ScriptContextError::UncompressedKeysNotAllowed)
+            Err(ContextError::UncompressedKeysNotAllowed)
         } else if pk.is_x_only_key() {
-            Err(ScriptContextError::XOnlyKeysNotAllowed(
+            Err(ContextError::XOnlyKeysNotAllowed(
                 pk.to_string(),
                 Self::name_str(),
             ))
@@ -510,9 +504,9 @@ impl ScriptContext for Segwitv0 {
         }
     }
 
-    fn check_witness<Pk: MiniscriptKey>(witness: &[Vec<u8>]) -> Result<(), ScriptContextError> {
+    fn check_witness<Pk: Key>(witness: &[Vec<u8>]) -> Result<(), ContextError> {
         if witness.len() > MAX_STANDARD_P2WSH_STACK_ITEMS {
-            return Err(ScriptContextError::MaxWitnessItemssExceeded {
+            return Err(ContextError::MaxWitnessItemssExceeded {
                 actual: witness.len(),
                 limit: MAX_STANDARD_P2WSH_STACK_ITEMS,
             });
@@ -520,61 +514,59 @@ impl ScriptContext for Segwitv0 {
         Ok(())
     }
 
-    fn check_global_consensus_validity<Pk: MiniscriptKey>(
+    fn check_global_consensus_validity<Pk: Key>(
         ms: &Miniscript<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
+    ) -> Result<(), ContextError> {
         if ms.ext.pk_cost > MAX_SCRIPT_SIZE {
-            return Err(ScriptContextError::MaxWitnessScriptSizeExceeded);
+            return Err(ContextError::MaxWitnessScriptSizeExceeded);
         }
 
         match ms.node {
             Terminal::PkK(ref pk) => Self::check_pk(pk),
             Terminal::Multi(_k, ref pks) => {
                 if pks.len() > MAX_PUBKEYS_PER_MULTISIG {
-                    return Err(ScriptContextError::CheckMultiSigLimitExceeded);
+                    return Err(ContextError::CheckMultiSigLimitExceeded);
                 }
                 for pk in pks.iter() {
                     Self::check_pk(pk)?;
                 }
                 Ok(())
             }
-            Terminal::MultiA(..) => Err(ScriptContextError::MultiANotAllowed),
+            Terminal::MultiA(..) => Err(ContextError::MultiANotAllowed),
             _ => Ok(()),
         }
     }
 
-    fn check_local_consensus_validity<Pk: MiniscriptKey>(
+    fn check_local_consensus_validity<Pk: Key>(
         ms: &Miniscript<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
+    ) -> Result<(), ContextError> {
         match ms.ext.ops.op_count() {
-            None => Err(ScriptContextError::MaxOpCountExceeded),
+            None => Err(ContextError::MaxOpCountExceeded),
             Some(op_count) if op_count > MAX_OPS_PER_SCRIPT => {
-                Err(ScriptContextError::MaxOpCountExceeded)
+                Err(ContextError::MaxOpCountExceeded)
             }
             _ => Ok(()),
         }
     }
 
-    fn check_global_policy_validity<Pk: MiniscriptKey>(
+    fn check_global_policy_validity<Pk: Key>(
         ms: &Miniscript<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
+    ) -> Result<(), ContextError> {
         if ms.ext.pk_cost > MAX_STANDARD_P2WSH_SCRIPT_SIZE {
-            return Err(ScriptContextError::MaxWitnessScriptSizeExceeded);
+            return Err(ContextError::MaxWitnessScriptSizeExceeded);
         }
         Ok(())
     }
 
-    fn check_local_policy_validity<Pk: MiniscriptKey>(
-        ms: &Miniscript<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
+    fn check_local_policy_validity<Pk: Key>(ms: &Miniscript<Pk, Self>) -> Result<(), ContextError> {
         // We don't need to know if this is actually a p2wsh as the standard satisfaction for
         // other Segwitv0 defined programs all require (much) less than 100 elements.
         // The witness script item is accounted for in max_satisfaction_witness_elements().
         match ms.max_satisfaction_witness_elements() {
             // No possible satisfactions
-            Err(_e) => Err(ScriptContextError::ImpossibleSatisfaction),
+            Err(_e) => Err(ContextError::ImpossibleSatisfaction),
             Ok(max_witness_items) if max_witness_items > MAX_STANDARD_P2WSH_STACK_ITEMS => {
-                Err(ScriptContextError::MaxWitnessItemssExceeded {
+                Err(ContextError::MaxWitnessItemssExceeded {
                     actual: max_witness_items,
                     limit: MAX_STANDARD_P2WSH_STACK_ITEMS,
                 })
@@ -583,12 +575,12 @@ impl ScriptContext for Segwitv0 {
         }
     }
 
-    fn max_satisfaction_size<Pk: MiniscriptKey>(ms: &Miniscript<Pk, Self>) -> Option<usize> {
+    fn max_satisfaction_size<Pk: Key>(ms: &Miniscript<Pk, Self>) -> Option<usize> {
         // The witness stack cost is the first element of the tuple
         ms.ext.max_sat_size.map(|x| x.0)
     }
 
-    fn pk_len<Pk: MiniscriptKey>(_pk: &Pk) -> usize {
+    fn pk_len<Pk: Key>(_pk: &Pk) -> usize {
         34
     }
 
@@ -601,33 +593,33 @@ impl ScriptContext for Segwitv0 {
     }
 }
 
-/// Tap ScriptContext
+/// Tap Context
 #[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
 pub enum Tap {}
 
-impl ScriptContext for Tap {
+impl Context for Tap {
     type Key = bitcoin::secp256k1::XOnlyPublicKey;
-    fn check_terminal_non_malleable<Pk: MiniscriptKey>(
+    fn check_terminal_non_malleable<Pk: Key>(
         _frag: &Terminal<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
+    ) -> Result<(), ContextError> {
         // No fragment is malleable in tapscript context.
         // Certain fragments like Multi are invalid, but are not malleable
         Ok(())
     }
 
     // No uncompressed keys in Tap context
-    fn check_pk<Pk: MiniscriptKey>(pk: &Pk) -> Result<(), ScriptContextError> {
+    fn check_pk<Pk: Key>(pk: &Pk) -> Result<(), ContextError> {
         if pk.is_uncompressed() {
-            Err(ScriptContextError::UncompressedKeysNotAllowed)
+            Err(ContextError::UncompressedKeysNotAllowed)
         } else {
             Ok(())
         }
     }
 
-    fn check_witness<Pk: MiniscriptKey>(witness: &[Vec<u8>]) -> Result<(), ScriptContextError> {
+    fn check_witness<Pk: Key>(witness: &[Vec<u8>]) -> Result<(), ContextError> {
         // Note that tapscript has a 1000 limit compared to 100 of segwitv0
         if witness.len() > MAX_STACK_SIZE {
-            return Err(ScriptContextError::MaxWitnessItemssExceeded {
+            return Err(ContextError::MaxWitnessItemssExceeded {
                 actual: witness.len(),
                 limit: MAX_STACK_SIZE,
             });
@@ -635,16 +627,16 @@ impl ScriptContext for Tap {
         Ok(())
     }
 
-    fn check_global_consensus_validity<Pk: MiniscriptKey>(
+    fn check_global_consensus_validity<Pk: Key>(
         ms: &Miniscript<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
+    ) -> Result<(), ContextError> {
         // No script size checks for global consensus rules
         // Should we really check for block limits here.
         // When the transaction sizes get close to block limits,
         // some guarantees are not easy to satisfy because of knapsack
         // constraints
         if ms.ext.pk_cost > MAX_BLOCK_WEIGHT as usize {
-            return Err(ScriptContextError::MaxWitnessScriptSizeExceeded);
+            return Err(ContextError::MaxWitnessScriptSizeExceeded);
         }
 
         match ms.node {
@@ -655,14 +647,14 @@ impl ScriptContext for Tap {
                 }
                 Ok(())
             }
-            Terminal::Multi(..) => Err(ScriptContextError::TaprootMultiDisabled),
+            Terminal::Multi(..) => Err(ContextError::TaprootMultiDisabled),
             _ => Ok(()),
         }
     }
 
-    fn check_local_consensus_validity<Pk: MiniscriptKey>(
+    fn check_local_consensus_validity<Pk: Key>(
         ms: &Miniscript<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
+    ) -> Result<(), ContextError> {
         // Taproot introduces the concept of sigops budget.
         // All valid miniscripts satisfy the sigops constraint
         // Whenever we add new fragment that uses pk(pk() or multi based on checksigadd)
@@ -677,7 +669,7 @@ impl ScriptContext for Tap {
             ms.ext.stack_elem_count_sat,
         ) {
             if s + h > MAX_STACK_SIZE {
-                return Err(ScriptContextError::StackSizeLimitExceeded {
+                return Err(ContextError::StackSizeLimitExceeded {
                     actual: s + h,
                     limit: MAX_STACK_SIZE,
                 });
@@ -686,20 +678,20 @@ impl ScriptContext for Tap {
         Ok(())
     }
 
-    fn check_global_policy_validity<Pk: MiniscriptKey>(
+    fn check_global_policy_validity<Pk: Key>(
         _ms: &Miniscript<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
+    ) -> Result<(), ContextError> {
         // No script rules, rules are subject to entire tx rules
         Ok(())
     }
 
-    fn check_local_policy_validity<Pk: MiniscriptKey>(
+    fn check_local_policy_validity<Pk: Key>(
         _ms: &Miniscript<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
+    ) -> Result<(), ContextError> {
         Ok(())
     }
 
-    fn max_satisfaction_size<Pk: MiniscriptKey>(ms: &Miniscript<Pk, Self>) -> Option<usize> {
+    fn max_satisfaction_size<Pk: Key>(ms: &Miniscript<Pk, Self>) -> Option<usize> {
         // The witness stack cost is the first element of the tuple
         ms.ext.max_sat_size.map(|x| x.0)
     }
@@ -708,7 +700,7 @@ impl ScriptContext for Tap {
         SigType::Schnorr
     }
 
-    fn pk_len<Pk: MiniscriptKey>(_pk: &Pk) -> usize {
+    fn pk_len<Pk: Key>(_pk: &Pk) -> usize {
         33
     }
 
@@ -717,18 +709,18 @@ impl ScriptContext for Tap {
     }
 }
 
-/// Bare ScriptContext
+/// Bare Context
 /// To be used as raw script pubkeys
 /// In general, it is not recommended to use Bare descriptors
 /// as they as strongly limited by standardness policies.
 #[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
 pub enum BareCtx {}
 
-impl ScriptContext for BareCtx {
+impl Context for BareCtx {
     type Key = bitcoin::PublicKey;
-    fn check_terminal_non_malleable<Pk: MiniscriptKey>(
+    fn check_terminal_non_malleable<Pk: Key>(
         _frag: &Terminal<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
+    ) -> Result<(), ContextError> {
         // Bare fragments can't contain miniscript because of standardness rules
         // This function is only used in compiler which already checks the standardness
         // and consensus rules, and because of the limited allowance of bare scripts
@@ -737,9 +729,9 @@ impl ScriptContext for BareCtx {
     }
 
     // No x-only keys in Bare context
-    fn check_pk<Pk: MiniscriptKey>(pk: &Pk) -> Result<(), ScriptContextError> {
+    fn check_pk<Pk: Key>(pk: &Pk) -> Result<(), ContextError> {
         if pk.is_x_only_key() {
-            Err(ScriptContextError::XOnlyKeysNotAllowed(
+            Err(ContextError::XOnlyKeysNotAllowed(
                 pk.to_string(),
                 Self::name_str(),
             ))
@@ -748,41 +740,41 @@ impl ScriptContext for BareCtx {
         }
     }
 
-    fn check_global_consensus_validity<Pk: MiniscriptKey>(
+    fn check_global_consensus_validity<Pk: Key>(
         ms: &Miniscript<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
+    ) -> Result<(), ContextError> {
         if ms.ext.pk_cost > MAX_SCRIPT_SIZE {
-            return Err(ScriptContextError::MaxWitnessScriptSizeExceeded);
+            return Err(ContextError::MaxWitnessScriptSizeExceeded);
         }
         match ms.node {
             Terminal::PkK(ref key) => Self::check_pk(key),
             Terminal::Multi(_k, ref pks) => {
                 if pks.len() > MAX_PUBKEYS_PER_MULTISIG {
-                    return Err(ScriptContextError::CheckMultiSigLimitExceeded);
+                    return Err(ContextError::CheckMultiSigLimitExceeded);
                 }
                 for pk in pks.iter() {
                     Self::check_pk(pk)?;
                 }
                 Ok(())
             }
-            Terminal::MultiA(..) => Err(ScriptContextError::MultiANotAllowed),
+            Terminal::MultiA(..) => Err(ContextError::MultiANotAllowed),
             _ => Ok(()),
         }
     }
 
-    fn check_local_consensus_validity<Pk: MiniscriptKey>(
+    fn check_local_consensus_validity<Pk: Key>(
         ms: &Miniscript<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
+    ) -> Result<(), ContextError> {
         match ms.ext.ops.op_count() {
-            None => Err(ScriptContextError::MaxOpCountExceeded),
+            None => Err(ContextError::MaxOpCountExceeded),
             Some(op_count) if op_count > MAX_OPS_PER_SCRIPT => {
-                Err(ScriptContextError::MaxOpCountExceeded)
+                Err(ContextError::MaxOpCountExceeded)
             }
             _ => Ok(()),
         }
     }
 
-    fn other_top_level_checks<Pk: MiniscriptKey>(ms: &Miniscript<Pk, Self>) -> Result<(), Error> {
+    fn other_top_level_checks<Pk: Key>(ms: &Miniscript<Pk, Self>) -> Result<(), Error> {
         match &ms.node {
             Terminal::Check(ref ms) => match &ms.node {
                 Terminal::RawPkH(_pkh) => Ok(()),
@@ -794,12 +786,12 @@ impl ScriptContext for BareCtx {
         }
     }
 
-    fn max_satisfaction_size<Pk: MiniscriptKey>(ms: &Miniscript<Pk, Self>) -> Option<usize> {
+    fn max_satisfaction_size<Pk: Key>(ms: &Miniscript<Pk, Self>) -> Option<usize> {
         // The witness stack cost is the first element of the tuple
         ms.ext.max_sat_size.map(|x| x.1)
     }
 
-    fn pk_len<Pk: MiniscriptKey>(pk: &Pk) -> usize {
+    fn pk_len<Pk: Key>(pk: &Pk) -> usize {
         if pk.is_uncompressed() {
             66
         } else {
@@ -823,49 +815,49 @@ impl ScriptContext for BareCtx {
 /// This context should *NOT* be used unless you know what you are doing.
 #[derive(Debug, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
 pub enum NoChecks {}
-impl ScriptContext for NoChecks {
+impl Context for NoChecks {
     // todo: When adding support for interpreter, we need a enum with all supported keys here
     type Key = bitcoin::PublicKey;
-    fn check_terminal_non_malleable<Pk: MiniscriptKey>(
+    fn check_terminal_non_malleable<Pk: Key>(
         _frag: &Terminal<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
+    ) -> Result<(), ContextError> {
         Ok(())
     }
 
     // No checks in NoChecks
-    fn check_pk<Pk: MiniscriptKey>(_pk: &Pk) -> Result<(), ScriptContextError> {
+    fn check_pk<Pk: Key>(_pk: &Pk) -> Result<(), ContextError> {
         Ok(())
     }
 
-    fn check_global_policy_validity<Pk: MiniscriptKey>(
+    fn check_global_policy_validity<Pk: Key>(
         _ms: &Miniscript<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
+    ) -> Result<(), ContextError> {
         Ok(())
     }
 
-    fn check_global_consensus_validity<Pk: MiniscriptKey>(
+    fn check_global_consensus_validity<Pk: Key>(
         _ms: &Miniscript<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
+    ) -> Result<(), ContextError> {
         Ok(())
     }
 
-    fn check_local_policy_validity<Pk: MiniscriptKey>(
+    fn check_local_policy_validity<Pk: Key>(
         _ms: &Miniscript<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
+    ) -> Result<(), ContextError> {
         Ok(())
     }
 
-    fn check_local_consensus_validity<Pk: MiniscriptKey>(
+    fn check_local_consensus_validity<Pk: Key>(
         _ms: &Miniscript<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
+    ) -> Result<(), ContextError> {
         Ok(())
     }
 
-    fn max_satisfaction_size<Pk: MiniscriptKey>(_ms: &Miniscript<Pk, Self>) -> Option<usize> {
+    fn max_satisfaction_size<Pk: Key>(_ms: &Miniscript<Pk, Self>) -> Option<usize> {
         panic!("Tried to compute a satisfaction size bound on a no-checks ecdsa miniscript")
     }
 
-    fn pk_len<Pk: MiniscriptKey>(_pk: &Pk) -> usize {
+    fn pk_len<Pk: Key>(_pk: &Pk) -> usize {
         panic!("Tried to compute a pk len bound on a no-checks ecdsa miniscript")
     }
 
@@ -874,24 +866,20 @@ impl ScriptContext for NoChecks {
         "NochecksEcdsa"
     }
 
-    fn check_witness<Pk: MiniscriptKey>(_witness: &[Vec<u8>]) -> Result<(), ScriptContextError> {
+    fn check_witness<Pk: Key>(_witness: &[Vec<u8>]) -> Result<(), ContextError> {
         // Only really need to do this for segwitv0 and legacy
         // Bare is already restrcited by standardness rules
         // and would reach these limits.
         Ok(())
     }
 
-    fn check_global_validity<Pk: MiniscriptKey>(
-        ms: &Miniscript<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
+    fn check_global_validity<Pk: Key>(ms: &Miniscript<Pk, Self>) -> Result<(), ContextError> {
         Self::check_global_consensus_validity(ms)?;
         Self::check_global_policy_validity(ms)?;
         Ok(())
     }
 
-    fn check_local_validity<Pk: MiniscriptKey>(
-        ms: &Miniscript<Pk, Self>,
-    ) -> Result<(), ScriptContextError> {
+    fn check_local_validity<Pk: Key>(ms: &Miniscript<Pk, Self>) -> Result<(), ContextError> {
         Self::check_global_consensus_validity(ms)?;
         Self::check_global_policy_validity(ms)?;
         Self::check_local_consensus_validity(ms)?;
@@ -899,18 +887,18 @@ impl ScriptContext for NoChecks {
         Ok(())
     }
 
-    fn top_level_type_check<Pk: MiniscriptKey>(ms: &Miniscript<Pk, Self>) -> Result<(), Error> {
+    fn top_level_type_check<Pk: Key>(ms: &Miniscript<Pk, Self>) -> Result<(), Error> {
         if ms.ty.corr.base != types::Base::B {
             return Err(Error::NonTopLevel(format!("{:?}", ms)));
         }
         Ok(())
     }
 
-    fn other_top_level_checks<Pk: MiniscriptKey>(_ms: &Miniscript<Pk, Self>) -> Result<(), Error> {
+    fn other_top_level_checks<Pk: Key>(_ms: &Miniscript<Pk, Self>) -> Result<(), Error> {
         Ok(())
     }
 
-    fn top_level_checks<Pk: MiniscriptKey>(ms: &Miniscript<Pk, Self>) -> Result<(), Error> {
+    fn top_level_checks<Pk: Key>(ms: &Miniscript<Pk, Self>) -> Result<(), Error> {
         Self::top_level_type_check(ms)?;
         Self::other_top_level_checks(ms)
     }
diff --git a/src/miniscript/decode.rs b/src/miniscript/decode.rs
index d5fa907a6..8f5cc163c 100644
--- a/src/miniscript/decode.rs
+++ b/src/miniscript/decode.rs
@@ -19,11 +19,11 @@ use crate::miniscript::lex::{Token as Tk, TokenIter};
 use crate::miniscript::limits::MAX_PUBKEYS_PER_MULTISIG;
 use crate::miniscript::types::extra_props::ExtData;
 use crate::miniscript::types::{Property, Type};
-use crate::miniscript::ScriptContext;
+use crate::miniscript::Context;
 use crate::prelude::*;
 #[cfg(doc)]
 use crate::Descriptor;
-use crate::{bitcoin, hash256, AbsLockTime, Error, Miniscript, MiniscriptKey, ToPublicKey};
+use crate::{bitcoin, hash256, AbsLockTime, Error, Key, Miniscript, ToPublicKey};
 
 fn return_none<T>(_: usize) -> Option<T> {
     None
@@ -122,7 +122,7 @@ enum NonTerm {
 /// The average user should always use the [`Descriptor`] APIs. Advanced users who want deal
 /// with Miniscript ASTs should use the [`Miniscript`] APIs.
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum Terminal<Pk: MiniscriptKey, Ctx: ScriptContext> {
+pub enum Terminal<Pk: Key, Ctx: Context> {
     /// `1`
     True,
     /// `0`
@@ -213,9 +213,9 @@ macro_rules! match_token {
 
 ///Vec representing terminals stack while decoding.
 #[derive(Debug)]
-struct TerminalStack<Pk: MiniscriptKey, Ctx: ScriptContext>(Vec<Miniscript<Pk, Ctx>>);
+struct TerminalStack<Pk: Key, Ctx: Context>(Vec<Miniscript<Pk, Ctx>>);
 
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> TerminalStack<Pk, Ctx> {
+impl<Pk: Key, Ctx: Context> TerminalStack<Pk, Ctx> {
     ///Wrapper around self.0.pop()
     fn pop(&mut self) -> Option<Miniscript<Pk, Ctx>> {
         self.0.pop()
@@ -283,9 +283,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> TerminalStack<Pk, Ctx> {
 
 /// Parse a script fragment into an `Miniscript`
 #[allow(unreachable_patterns)]
-pub fn parse<Ctx: ScriptContext>(
-    tokens: &mut TokenIter,
-) -> Result<Miniscript<Ctx::Key, Ctx>, Error> {
+pub fn parse<Ctx: Context>(tokens: &mut TokenIter) -> Result<Miniscript<Ctx::Key, Ctx>, Error> {
     let mut non_term = Vec::with_capacity(tokens.len());
     let mut term = TerminalStack(Vec::with_capacity(tokens.len()));
 
diff --git a/src/miniscript/iter.rs b/src/miniscript/iter.rs
index f64b350ec..1b30ad3e1 100644
--- a/src/miniscript/iter.rs
+++ b/src/miniscript/iter.rs
@@ -10,11 +10,11 @@ use core::ops::Deref;
 use sync::Arc;
 
 use super::decode::Terminal;
-use super::{Miniscript, MiniscriptKey, ScriptContext};
+use super::{Context, Key, Miniscript};
 use crate::prelude::*;
 
 /// Iterator-related extensions for [Miniscript]
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
+impl<Pk: Key, Ctx: Context> Miniscript<Pk, Ctx> {
     /// Creates a new [Iter] iterator that will iterate over all [Miniscript] items within
     /// AST by traversing its branches. For the specific algorithm please see
     /// [Iter::next] function.
@@ -109,7 +109,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
 
 /// Iterator for traversing all [Miniscript] miniscript AST references starting from some specific
 /// node which constructs the iterator via [Miniscript::iter] method.
-pub struct Iter<'a, Pk: MiniscriptKey, Ctx: ScriptContext> {
+pub struct Iter<'a, Pk: Key, Ctx: Context> {
     next: Option<&'a Miniscript<Pk, Ctx>>,
     // Here we store vec of path elements, where each element is a tuple, consisting of:
     // 1. Miniscript node on the path
@@ -117,7 +117,7 @@ pub struct Iter<'a, Pk: MiniscriptKey, Ctx: ScriptContext> {
     path: Vec<(&'a Miniscript<Pk, Ctx>, usize)>,
 }
 
-impl<'a, Pk: MiniscriptKey, Ctx: ScriptContext> Iter<'a, Pk, Ctx> {
+impl<'a, Pk: Key, Ctx: Context> Iter<'a, Pk, Ctx> {
     fn new(miniscript: &'a Miniscript<Pk, Ctx>) -> Self {
         Iter {
             next: Some(miniscript),
@@ -126,7 +126,7 @@ impl<'a, Pk: MiniscriptKey, Ctx: ScriptContext> Iter<'a, Pk, Ctx> {
     }
 }
 
-impl<'a, Pk: MiniscriptKey, Ctx: ScriptContext> Iterator for Iter<'a, Pk, Ctx> {
+impl<'a, Pk: Key, Ctx: Context> Iterator for Iter<'a, Pk, Ctx> {
     type Item = &'a Miniscript<Pk, Ctx>;
 
     /// First, the function returns `self`, then the first child of the self (if any),
@@ -169,15 +169,15 @@ impl<'a, Pk: MiniscriptKey, Ctx: ScriptContext> Iterator for Iter<'a, Pk, Ctx> {
     }
 }
 
-/// Iterator for traversing all [MiniscriptKey]'s in AST starting from some specific node which
+/// Iterator for traversing all [Key]'s in AST starting from some specific node which
 /// constructs the iterator via [Miniscript::iter_pk] method.
-pub struct PkIter<'a, Pk: MiniscriptKey, Ctx: ScriptContext> {
+pub struct PkIter<'a, Pk: Key, Ctx: Context> {
     node_iter: Iter<'a, Pk, Ctx>,
     curr_node: Option<&'a Miniscript<Pk, Ctx>>,
     key_index: usize,
 }
 
-impl<'a, Pk: MiniscriptKey, Ctx: ScriptContext> PkIter<'a, Pk, Ctx> {
+impl<'a, Pk: Key, Ctx: Context> PkIter<'a, Pk, Ctx> {
     fn new(miniscript: &'a Miniscript<Pk, Ctx>) -> Self {
         let mut iter = Iter::new(miniscript);
         PkIter {
@@ -188,7 +188,7 @@ impl<'a, Pk: MiniscriptKey, Ctx: ScriptContext> PkIter<'a, Pk, Ctx> {
     }
 }
 
-impl<'a, Pk: MiniscriptKey, Ctx: ScriptContext> Iterator for PkIter<'a, Pk, Ctx> {
+impl<'a, Pk: Key, Ctx: Context> Iterator for PkIter<'a, Pk, Ctx> {
     type Item = Pk;
 
     fn next(&mut self) -> Option<Self::Item> {
diff --git a/src/miniscript/mod.rs b/src/miniscript/mod.rs
index ed607977c..a5ec49ff8 100644
--- a/src/miniscript/mod.rs
+++ b/src/miniscript/mod.rs
@@ -41,17 +41,17 @@ use sync::Arc;
 
 use self::lex::{lex, TokenIter};
 use self::types::Property;
-pub use crate::miniscript::context::ScriptContext;
+pub use crate::miniscript::context::Context;
 use crate::miniscript::decode::Terminal;
 use crate::miniscript::types::extra_props::ExtData;
 use crate::miniscript::types::Type;
-use crate::{expression, Error, ForEachKey, MiniscriptKey, ToPublicKey, TranslatePk, Translator};
+use crate::{expression, Error, ForEachKey, Key, ToPublicKey, TranslatePk, Translator};
 #[cfg(test)]
 mod ms_tests;
 
 /// The top-level miniscript abstract syntax tree (AST).
 #[derive(Clone)]
-pub struct Miniscript<Pk: MiniscriptKey, Ctx: ScriptContext> {
+pub struct Miniscript<Pk: Key, Ctx: Context> {
     /// A node in the AST.
     pub node: Terminal<Pk, Ctx>,
     /// The correctness and malleability type information for the AST node.
@@ -62,7 +62,7 @@ pub struct Miniscript<Pk: MiniscriptKey, Ctx: ScriptContext> {
     phantom: PhantomData<Ctx>,
 }
 
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
+impl<Pk: Key, Ctx: Context> Miniscript<Pk, Ctx> {
     /// Add type information(Type and Extdata) to Miniscript based on
     /// `AstElem` fragment. Dependent on display and clone because of Error
     /// Display code of type_check.
@@ -241,7 +241,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
     }
 }
 
-impl<Ctx: ScriptContext> Miniscript<Ctx::Key, Ctx> {
+impl<Ctx: Context> Miniscript<Ctx::Key, Ctx> {
     /// Attempt to parse an insane(scripts don't clear sanity checks)
     /// script into a Miniscript representation.
     /// Use this to parse scripts with repeated pubkeys, timelock mixing, malleable
@@ -323,7 +323,7 @@ impl<Ctx: ScriptContext> Miniscript<Ctx::Key, Ctx> {
 /// `PartialOrd` of `Miniscript` must depend only on node and not the type information.
 ///
 /// The type information and extra properties are implied by the AST.
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> PartialOrd for Miniscript<Pk, Ctx> {
+impl<Pk: Key, Ctx: Context> PartialOrd for Miniscript<Pk, Ctx> {
     fn partial_cmp(&self, other: &Miniscript<Pk, Ctx>) -> Option<cmp::Ordering> {
         Some(self.node.cmp(&other.node))
     }
@@ -332,7 +332,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> PartialOrd for Miniscript<Pk, Ctx> {
 /// `Ord` of `Miniscript` must depend only on node and not the type information.
 ///
 /// The type information and extra properties are implied by the AST.
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> Ord for Miniscript<Pk, Ctx> {
+impl<Pk: Key, Ctx: Context> Ord for Miniscript<Pk, Ctx> {
     fn cmp(&self, other: &Miniscript<Pk, Ctx>) -> cmp::Ordering {
         self.node.cmp(&other.node)
     }
@@ -341,7 +341,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Ord for Miniscript<Pk, Ctx> {
 /// `PartialEq` of `Miniscript` must depend only on node and not the type information.
 ///
 /// The type information and extra properties are implied by the AST.
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> PartialEq for Miniscript<Pk, Ctx> {
+impl<Pk: Key, Ctx: Context> PartialEq for Miniscript<Pk, Ctx> {
     fn eq(&self, other: &Miniscript<Pk, Ctx>) -> bool {
         self.node.eq(&other.node)
     }
@@ -350,30 +350,30 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> PartialEq for Miniscript<Pk, Ctx> {
 /// `Eq` of `Miniscript` must depend only on node and not the type information.
 ///
 /// The type information and extra properties are implied by the AST.
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> Eq for Miniscript<Pk, Ctx> {}
+impl<Pk: Key, Ctx: Context> Eq for Miniscript<Pk, Ctx> {}
 
 /// `Hash` of `Miniscript` must depend only on node and not the type information.
 ///
 /// The type information and extra properties are implied by the AST.
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> hash::Hash for Miniscript<Pk, Ctx> {
+impl<Pk: Key, Ctx: Context> hash::Hash for Miniscript<Pk, Ctx> {
     fn hash<H: hash::Hasher>(&self, state: &mut H) {
         self.node.hash(state);
     }
 }
 
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> fmt::Debug for Miniscript<Pk, Ctx> {
+impl<Pk: Key, Ctx: Context> fmt::Debug for Miniscript<Pk, Ctx> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{:?}", self.node)
     }
 }
 
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> fmt::Display for Miniscript<Pk, Ctx> {
+impl<Pk: Key, Ctx: Context> fmt::Display for Miniscript<Pk, Ctx> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}", self.node)
     }
 }
 
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> ForEachKey<Pk> for Miniscript<Pk, Ctx> {
+impl<Pk: Key, Ctx: Context> ForEachKey<Pk> for Miniscript<Pk, Ctx> {
     fn for_each_key<'a, F: FnMut(&'a Pk) -> bool>(&'a self, mut pred: F) -> bool {
         for ms in self.pre_order_iter() {
             match ms.node {
@@ -401,9 +401,9 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> ForEachKey<Pk> for Miniscript<Pk, Ct
 
 impl<Pk, Q, Ctx> TranslatePk<Pk, Q> for Miniscript<Pk, Ctx>
 where
-    Pk: MiniscriptKey,
-    Q: MiniscriptKey,
-    Ctx: ScriptContext,
+    Pk: Key,
+    Q: Key,
+    Ctx: Context,
 {
     type Output = Miniscript<Q, Ctx>;
 
@@ -417,14 +417,14 @@ where
     }
 }
 
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
+impl<Pk: Key, Ctx: Context> Miniscript<Pk, Ctx> {
     pub(super) fn translate_pk_ctx<Q, CtxQ, T, FuncError>(
         &self,
         t: &mut T,
     ) -> Result<Miniscript<Q, CtxQ>, TranslateErr<FuncError>>
     where
-        Q: MiniscriptKey,
-        CtxQ: ScriptContext,
+        Q: Key,
+        CtxQ: Context,
         T: Translator<Pk, Q, FuncError>,
     {
         let mut translated = vec![];
@@ -499,7 +499,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
 }
 
 impl_block_str!(
-    ;Ctx; ScriptContext,
+    ;Ctx; Context,
     Miniscript<Pk, Ctx>,
     /// Attempt to parse an insane(scripts don't clear sanity checks)
     /// from string into a Miniscript representation.
@@ -515,7 +515,7 @@ impl_block_str!(
 );
 
 impl_block_str!(
-    ;Ctx; ScriptContext,
+    ;Ctx; Context,
     Miniscript<Pk, Ctx>,
     /// Attempt to parse an Miniscripts that don't follow the spec.
     /// Use this to parse scripts with repeated pubkeys, timelock mixing, malleable
@@ -538,7 +538,7 @@ impl_block_str!(
 );
 
 impl_from_tree!(
-    ;Ctx; ScriptContext,
+    ;Ctx; Context,
     Arc<Miniscript<Pk, Ctx>>,
     fn from_tree(top: &expression::Tree) -> Result<Arc<Miniscript<Pk, Ctx>>, Error> {
         Ok(Arc::new(expression::FromTree::from_tree(top)?))
@@ -546,7 +546,7 @@ impl_from_tree!(
 );
 
 impl_from_tree!(
-    ;Ctx; ScriptContext,
+    ;Ctx; Context,
     Miniscript<Pk, Ctx>,
     /// Parse an expression tree into a Miniscript. As a general rule, this
     /// should not be called directly; rather go through the descriptor API.
@@ -557,7 +557,7 @@ impl_from_tree!(
 );
 
 impl_from_str!(
-    ;Ctx; ScriptContext,
+    ;Ctx; Context,
     Miniscript<Pk, Ctx>,
     type Err = Error;,
     /// Parse a Miniscript from string and perform sanity checks
@@ -569,7 +569,7 @@ impl_from_str!(
     }
 );
 
-serde_string_impl_pk!(Miniscript, "a miniscript", Ctx; ScriptContext);
+serde_string_impl_pk!(Miniscript, "a miniscript", Ctx; Context);
 
 /// Provides a Double SHA256 `Hash` type that displays forwards.
 pub mod hash256 {
@@ -595,7 +595,7 @@ mod tests {
     use bitcoin::{self, secp256k1, Sequence};
     use sync::Arc;
 
-    use super::{Miniscript, ScriptContext, Segwitv0, Tap};
+    use super::{Context, Miniscript, Segwitv0, Tap};
     use crate::miniscript::types::{self, ExtData, Property, Type};
     use crate::miniscript::Terminal;
     use crate::policy::Liftable;
@@ -627,7 +627,7 @@ mod tests {
         ret
     }
 
-    fn string_rtt<Ctx: ScriptContext>(
+    fn string_rtt<Ctx: Context>(
         script: Miniscript<bitcoin::PublicKey, Ctx>,
         expected_debug: &str,
         expected_display: &str,
@@ -645,7 +645,7 @@ mod tests {
         assert_eq!(roundtrip, script);
     }
 
-    fn string_display_debug_test<Ctx: ScriptContext>(
+    fn string_display_debug_test<Ctx: Context>(
         script: Miniscript<bitcoin::PublicKey, Ctx>,
         expected_debug: &str,
         expected_display: &str,
@@ -661,7 +661,7 @@ mod tests {
         }
     }
 
-    fn dummy_string_rtt<Ctx: ScriptContext>(
+    fn dummy_string_rtt<Ctx: Context>(
         script: Miniscript<String, Ctx>,
         expected_debug: &str,
         expected_display: &str,
diff --git a/src/miniscript/satisfy.rs b/src/miniscript/satisfy.rs
index 7ba993e49..01b035161 100644
--- a/src/miniscript/satisfy.rs
+++ b/src/miniscript/satisfy.rs
@@ -17,7 +17,7 @@ use sync::Arc;
 use super::context::SigType;
 use crate::prelude::*;
 use crate::util::witness_size;
-use crate::{Miniscript, MiniscriptKey, ScriptContext, Terminal, ToPublicKey};
+use crate::{Context, Key, Miniscript, Terminal, ToPublicKey};
 
 /// Type alias for 32 byte Preimage.
 pub type Preimage32 = [u8; 32];
@@ -25,7 +25,7 @@ pub type Preimage32 = [u8; 32];
 /// Every method has a default implementation that simply returns `None`
 /// on every query. Users are expected to override the methods that they
 /// have data for.
-pub trait Satisfier<Pk: MiniscriptKey + ToPublicKey> {
+pub trait Satisfier<Pk: Key + ToPublicKey> {
     /// Given a public key, look up an ECDSA signature with that key
     fn lookup_ecdsa_sig(&self, _: &Pk) -> Option<bitcoin::ecdsa::Signature> {
         None
@@ -116,9 +116,9 @@ pub trait Satisfier<Pk: MiniscriptKey + ToPublicKey> {
 }
 
 // Allow use of `()` as a "no conditions available" satisfier
-impl<Pk: MiniscriptKey + ToPublicKey> Satisfier<Pk> for () {}
+impl<Pk: Key + ToPublicKey> Satisfier<Pk> for () {}
 
-impl<Pk: MiniscriptKey + ToPublicKey> Satisfier<Pk> for Sequence {
+impl<Pk: Key + ToPublicKey> Satisfier<Pk> for Sequence {
     fn check_older(&self, n: Sequence) -> bool {
         if !self.is_relative_lock_time() {
             return false;
@@ -142,7 +142,7 @@ impl<Pk: MiniscriptKey + ToPublicKey> Satisfier<Pk> for Sequence {
     }
 }
 
-impl<Pk: MiniscriptKey + ToPublicKey> Satisfier<Pk> for absolute::LockTime {
+impl<Pk: Key + ToPublicKey> Satisfier<Pk> for absolute::LockTime {
     fn check_after(&self, n: absolute::LockTime) -> bool {
         use absolute::LockTime::*;
 
@@ -153,13 +153,13 @@ impl<Pk: MiniscriptKey + ToPublicKey> Satisfier<Pk> for absolute::LockTime {
         }
     }
 }
-impl<Pk: MiniscriptKey + ToPublicKey> Satisfier<Pk> for HashMap<Pk, bitcoin::ecdsa::Signature> {
+impl<Pk: Key + ToPublicKey> Satisfier<Pk> for HashMap<Pk, bitcoin::ecdsa::Signature> {
     fn lookup_ecdsa_sig(&self, key: &Pk) -> Option<bitcoin::ecdsa::Signature> {
         self.get(key).copied()
     }
 }
 
-impl<Pk: MiniscriptKey + ToPublicKey> Satisfier<Pk>
+impl<Pk: Key + ToPublicKey> Satisfier<Pk>
     for HashMap<(Pk, TapLeafHash), bitcoin::taproot::Signature>
 {
     fn lookup_tap_leaf_script_sig(
@@ -175,10 +175,10 @@ impl<Pk: MiniscriptKey + ToPublicKey> Satisfier<Pk>
     }
 }
 
-impl<Pk: MiniscriptKey + ToPublicKey> Satisfier<Pk>
+impl<Pk: Key + ToPublicKey> Satisfier<Pk>
     for HashMap<hash160::Hash, (Pk, bitcoin::ecdsa::Signature)>
 where
-    Pk: MiniscriptKey + ToPublicKey,
+    Pk: Key + ToPublicKey,
 {
     fn lookup_ecdsa_sig(&self, key: &Pk) -> Option<bitcoin::ecdsa::Signature> {
         self.get(&key.to_pubkeyhash(SigType::Ecdsa)).map(|x| x.1)
@@ -197,10 +197,10 @@ where
     }
 }
 
-impl<Pk: MiniscriptKey + ToPublicKey> Satisfier<Pk>
+impl<Pk: Key + ToPublicKey> Satisfier<Pk>
     for HashMap<(hash160::Hash, TapLeafHash), (Pk, bitcoin::taproot::Signature)>
 where
-    Pk: MiniscriptKey + ToPublicKey,
+    Pk: Key + ToPublicKey,
 {
     fn lookup_tap_leaf_script_sig(
         &self,
@@ -220,7 +220,7 @@ where
     }
 }
 
-impl<'a, Pk: MiniscriptKey + ToPublicKey, S: Satisfier<Pk>> Satisfier<Pk> for &'a S {
+impl<'a, Pk: Key + ToPublicKey, S: Satisfier<Pk>> Satisfier<Pk> for &'a S {
     fn lookup_ecdsa_sig(&self, p: &Pk) -> Option<bitcoin::ecdsa::Signature> {
         (**self).lookup_ecdsa_sig(p)
     }
@@ -290,7 +290,7 @@ impl<'a, Pk: MiniscriptKey + ToPublicKey, S: Satisfier<Pk>> Satisfier<Pk> for &'
     }
 }
 
-impl<'a, Pk: MiniscriptKey + ToPublicKey, S: Satisfier<Pk>> Satisfier<Pk> for &'a mut S {
+impl<'a, Pk: Key + ToPublicKey, S: Satisfier<Pk>> Satisfier<Pk> for &'a mut S {
     fn lookup_ecdsa_sig(&self, p: &Pk) -> Option<bitcoin::ecdsa::Signature> {
         (**self).lookup_ecdsa_sig(p)
     }
@@ -365,7 +365,7 @@ macro_rules! impl_tuple_satisfier {
         #[allow(non_snake_case)]
         impl<$($ty,)* Pk> Satisfier<Pk> for ($($ty,)*)
         where
-            Pk: MiniscriptKey + ToPublicKey,
+            Pk: Key + ToPublicKey,
             $($ty: Satisfier< Pk>,)*
         {
             fn lookup_ecdsa_sig(&self, key: &Pk) -> Option<bitcoin::ecdsa::Signature> {
@@ -573,7 +573,7 @@ impl Ord for Witness {
 
 impl Witness {
     /// Turn a signature into (part of) a satisfaction
-    fn signature<Pk: ToPublicKey, S: Satisfier<Pk>, Ctx: ScriptContext>(
+    fn signature<Pk: ToPublicKey, S: Satisfier<Pk>, Ctx: Context>(
         sat: S,
         pk: &Pk,
         leaf_hash: &TapLeafHash,
@@ -594,7 +594,7 @@ impl Witness {
     }
 
     /// Turn a public key related to a pkh into (part of) a satisfaction
-    fn pkh_public_key<Pk: ToPublicKey, S: Satisfier<Pk>, Ctx: ScriptContext>(
+    fn pkh_public_key<Pk: ToPublicKey, S: Satisfier<Pk>, Ctx: Context>(
         sat: S,
         pkh: &hash160::Hash,
     ) -> Self {
@@ -613,7 +613,7 @@ impl Witness {
     }
 
     /// Turn a key/signature pair related to a pkh into (part of) a satisfaction
-    fn pkh_signature<Pk: ToPublicKey, S: Satisfier<Pk>, Ctx: ScriptContext>(
+    fn pkh_signature<Pk: ToPublicKey, S: Satisfier<Pk>, Ctx: Context>(
         sat: S,
         pkh: &hash160::Hash,
         leaf_hash: &TapLeafHash,
@@ -727,8 +727,8 @@ impl Satisfaction {
         min_fn: &mut F,
     ) -> Self
     where
-        Pk: MiniscriptKey + ToPublicKey,
-        Ctx: ScriptContext,
+        Pk: Key + ToPublicKey,
+        Ctx: Context,
         Sat: Satisfier<Pk>,
         F: FnMut(Satisfaction, Satisfaction) -> Satisfaction,
     {
@@ -845,8 +845,8 @@ impl Satisfaction {
         min_fn: &mut F,
     ) -> Self
     where
-        Pk: MiniscriptKey + ToPublicKey,
-        Ctx: ScriptContext,
+        Pk: Key + ToPublicKey,
+        Ctx: Context,
         Sat: Satisfier<Pk>,
         F: FnMut(Satisfaction, Satisfaction) -> Satisfaction,
     {
@@ -973,8 +973,8 @@ impl Satisfaction {
         thresh_fn: &mut G,
     ) -> Self
     where
-        Pk: MiniscriptKey + ToPublicKey,
-        Ctx: ScriptContext,
+        Pk: Key + ToPublicKey,
+        Ctx: Context,
         Sat: Satisfier<Pk>,
         F: FnMut(Satisfaction, Satisfaction) -> Satisfaction,
         G: FnMut(
@@ -1292,8 +1292,8 @@ impl Satisfaction {
         thresh_fn: &mut G,
     ) -> Self
     where
-        Pk: MiniscriptKey + ToPublicKey,
-        Ctx: ScriptContext,
+        Pk: Key + ToPublicKey,
+        Ctx: Context,
         Sat: Satisfier<Pk>,
         F: FnMut(Satisfaction, Satisfaction) -> Satisfaction,
         G: FnMut(
@@ -1454,11 +1454,7 @@ impl Satisfaction {
     }
 
     /// Produce a satisfaction non-malleable satisfaction
-    pub(super) fn satisfy<
-        Pk: MiniscriptKey + ToPublicKey,
-        Ctx: ScriptContext,
-        Sat: Satisfier<Pk>,
-    >(
+    pub(super) fn satisfy<Pk: Key + ToPublicKey, Ctx: Context, Sat: Satisfier<Pk>>(
         term: &Terminal<Pk, Ctx>,
         stfr: &Sat,
         root_has_sig: bool,
@@ -1475,11 +1471,7 @@ impl Satisfaction {
     }
 
     /// Produce a satisfaction(possibly malleable)
-    pub(super) fn satisfy_mall<
-        Pk: MiniscriptKey + ToPublicKey,
-        Ctx: ScriptContext,
-        Sat: Satisfier<Pk>,
-    >(
+    pub(super) fn satisfy_mall<Pk: Key + ToPublicKey, Ctx: Context, Sat: Satisfier<Pk>>(
         term: &Terminal<Pk, Ctx>,
         stfr: &Sat,
         root_has_sig: bool,
diff --git a/src/miniscript/types/correctness.rs b/src/miniscript/types/correctness.rs
index a4c3b2fa9..76706e961 100644
--- a/src/miniscript/types/correctness.rs
+++ b/src/miniscript/types/correctness.rs
@@ -3,7 +3,7 @@
 //! Correctness/Soundness type properties
 
 use super::{ErrorKind, Property};
-use crate::ScriptContext;
+use crate::Context;
 
 /// Basic type representing where the fragment can go
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
@@ -131,7 +131,7 @@ impl Property for Correctness {
         }
     }
 
-    fn from_pk_k<Ctx: ScriptContext>() -> Self {
+    fn from_pk_k<Ctx: Context>() -> Self {
         Correctness {
             base: Base::K,
             input: Input::OneNonZero,
@@ -140,7 +140,7 @@ impl Property for Correctness {
         }
     }
 
-    fn from_pk_h<Ctx: ScriptContext>() -> Self {
+    fn from_pk_h<Ctx: Context>() -> Self {
         Correctness {
             base: Base::K,
             input: Input::AnyNonZero,
diff --git a/src/miniscript/types/extra_props.rs b/src/miniscript/types/extra_props.rs
index 3f12e5a88..6ad233f70 100644
--- a/src/miniscript/types/extra_props.rs
+++ b/src/miniscript/types/extra_props.rs
@@ -8,10 +8,10 @@ use core::iter::once;
 
 use bitcoin::{absolute, Sequence};
 
-use super::{Error, ErrorKind, Property, ScriptContext};
+use super::{Context, Error, ErrorKind, Property};
 use crate::miniscript::context::SigType;
 use crate::prelude::*;
-use crate::{script_num_size, MiniscriptKey, Terminal};
+use crate::{script_num_size, Key, Terminal};
 
 /// Timelock information for satisfaction of a fragment.
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Default, Hash)]
@@ -183,7 +183,7 @@ impl Property for ExtData {
         }
     }
 
-    fn from_pk_k<Ctx: ScriptContext>() -> Self {
+    fn from_pk_k<Ctx: Context>() -> Self {
         ExtData {
             pk_cost: match Ctx::sig_type() {
                 SigType::Ecdsa => 34,
@@ -204,7 +204,7 @@ impl Property for ExtData {
         }
     }
 
-    fn from_pk_h<Ctx: ScriptContext>() -> Self {
+    fn from_pk_h<Ctx: Context>() -> Self {
         ExtData {
             pk_cost: 24,
             has_free_verify: false,
@@ -896,8 +896,8 @@ impl Property for ExtData {
     ) -> Result<Self, Error<Pk, Ctx>>
     where
         C: FnMut(usize) -> Option<Self>,
-        Ctx: ScriptContext,
-        Pk: MiniscriptKey,
+        Ctx: Context,
+        Pk: Key,
     {
         let wrap_err = |result: Result<Self, ErrorKind>| {
             result.map_err(|kind| Error {
diff --git a/src/miniscript/types/malleability.rs b/src/miniscript/types/malleability.rs
index d1b8e4dba..59c62bb06 100644
--- a/src/miniscript/types/malleability.rs
+++ b/src/miniscript/types/malleability.rs
@@ -3,7 +3,7 @@
 //! Malleability-related Type properties
 
 use super::{ErrorKind, Property};
-use crate::ScriptContext;
+use crate::Context;
 
 /// Whether the fragment has a dissatisfaction, and if so, whether
 /// it is unique. Affects both correctness and malleability-freeness,
@@ -83,7 +83,7 @@ impl Property for Malleability {
         }
     }
 
-    fn from_pk_k<Ctx: ScriptContext>() -> Self {
+    fn from_pk_k<Ctx: Context>() -> Self {
         Malleability {
             dissat: Dissat::Unique,
             safe: true,
@@ -91,7 +91,7 @@ impl Property for Malleability {
         }
     }
 
-    fn from_pk_h<Ctx: ScriptContext>() -> Self {
+    fn from_pk_h<Ctx: Context>() -> Self {
         Malleability {
             dissat: Dissat::Unique,
             safe: true,
diff --git a/src/miniscript/types/mod.rs b/src/miniscript/types/mod.rs
index 35a29605e..cc28ecf39 100644
--- a/src/miniscript/types/mod.rs
+++ b/src/miniscript/types/mod.rs
@@ -17,8 +17,8 @@ use bitcoin::{absolute, Sequence};
 pub use self::correctness::{Base, Correctness, Input};
 pub use self::extra_props::ExtData;
 pub use self::malleability::{Dissat, Malleability};
-use super::ScriptContext;
-use crate::{MiniscriptKey, Terminal};
+use super::Context;
+use crate::{Key, Terminal};
 
 /// None-returning function to help type inference when we need a
 /// closure that simply returns `None`
@@ -88,14 +88,14 @@ pub enum ErrorKind {
 
 /// Error type for typechecking
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
-pub struct Error<Pk: MiniscriptKey, Ctx: ScriptContext> {
+pub struct Error<Pk: Key, Ctx: Context> {
     /// The fragment that failed typecheck
     pub fragment: Terminal<Pk, Ctx>,
     /// The reason that typechecking failed
     pub error: ErrorKind,
 }
 
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> fmt::Display for Error<Pk, Ctx> {
+impl<Pk: Key, Ctx: Context> fmt::Display for Error<Pk, Ctx> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self.error {
             ErrorKind::InvalidTime => write!(
@@ -205,7 +205,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> fmt::Display for Error<Pk, Ctx> {
 }
 
 #[cfg(feature = "std")]
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> error::Error for Error<Pk, Ctx> {
+impl<Pk: Key, Ctx: Context> error::Error for Error<Pk, Ctx> {
     fn cause(&self) -> Option<&dyn error::Error> {
         None
     }
@@ -246,10 +246,10 @@ pub trait Property: Sized {
     fn from_false() -> Self;
 
     /// Type property of the `PkK` fragment
-    fn from_pk_k<Ctx: ScriptContext>() -> Self;
+    fn from_pk_k<Ctx: Context>() -> Self;
 
     /// Type property of the `PkH` fragment
-    fn from_pk_h<Ctx: ScriptContext>() -> Self;
+    fn from_pk_h<Ctx: Context>() -> Self;
 
     /// Type property of a `Multi` fragment
     fn from_multi(k: usize, n: usize) -> Self;
@@ -380,8 +380,8 @@ pub trait Property: Sized {
     ) -> Result<Self, Error<Pk, Ctx>>
     where
         C: FnMut(usize) -> Option<Self>,
-        Pk: MiniscriptKey,
-        Ctx: ScriptContext,
+        Pk: Key,
+        Ctx: Context,
     {
         let mut get_child = |sub, n| {
             child(n)
@@ -547,14 +547,14 @@ impl Property for Type {
         }
     }
 
-    fn from_pk_k<Ctx: ScriptContext>() -> Self {
+    fn from_pk_k<Ctx: Context>() -> Self {
         Type {
             corr: Property::from_pk_k::<Ctx>(),
             mall: Property::from_pk_k::<Ctx>(),
         }
     }
 
-    fn from_pk_h<Ctx: ScriptContext>() -> Self {
+    fn from_pk_h<Ctx: Context>() -> Self {
         Type {
             corr: Property::from_pk_h::<Ctx>(),
             mall: Property::from_pk_h::<Ctx>(),
@@ -775,8 +775,8 @@ impl Property for Type {
     ) -> Result<Self, Error<Pk, Ctx>>
     where
         C: FnMut(usize) -> Option<Self>,
-        Pk: MiniscriptKey,
-        Ctx: ScriptContext,
+        Pk: Key,
+        Ctx: Context,
     {
         let wrap_err = |result: Result<Self, ErrorKind>| {
             result.map_err(|kind| Error {
diff --git a/src/policy/compiler.rs b/src/policy/compiler.rs
index c3c13ec62..25d91a0b1 100644
--- a/src/policy/compiler.rs
+++ b/src/policy/compiler.rs
@@ -15,10 +15,10 @@ use sync::Arc;
 use crate::miniscript::context::SigType;
 use crate::miniscript::limits::MAX_PUBKEYS_PER_MULTISIG;
 use crate::miniscript::types::{self, ErrorKind, ExtData, Property, Type};
-use crate::miniscript::ScriptContext;
+use crate::miniscript::Context;
 use crate::policy::Concrete;
 use crate::prelude::*;
-use crate::{policy, Miniscript, MiniscriptKey, Terminal};
+use crate::{policy, Key, Miniscript, Terminal};
 
 type PolicyCache<Pk, Ctx> =
     BTreeMap<(Concrete<Pk>, OrdF64, Option<OrdF64>), BTreeMap<CompilationKey, AstElemExt<Pk, Ctx>>>;
@@ -172,7 +172,7 @@ impl Property for CompilerExtData {
         }
     }
 
-    fn from_pk_k<Ctx: ScriptContext>() -> Self {
+    fn from_pk_k<Ctx: Context>() -> Self {
         CompilerExtData {
             branch_prob: None,
             sat_cost: match Ctx::sig_type() {
@@ -183,7 +183,7 @@ impl Property for CompilerExtData {
         }
     }
 
-    fn from_pk_h<Ctx: ScriptContext>() -> Self {
+    fn from_pk_h<Ctx: Context>() -> Self {
         CompilerExtData {
             branch_prob: None,
             sat_cost: match Ctx::sig_type() {
@@ -454,14 +454,14 @@ impl Property for CompilerExtData {
 
 /// Miniscript AST fragment with additional data needed by the compiler
 #[derive(Clone, Debug)]
-struct AstElemExt<Pk: MiniscriptKey, Ctx: ScriptContext> {
+struct AstElemExt<Pk: Key, Ctx: Context> {
     /// The actual Miniscript fragment with type information
     ms: Arc<Miniscript<Pk, Ctx>>,
     /// Its "type" in terms of compiler data
     comp_ext_data: CompilerExtData,
 }
 
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> AstElemExt<Pk, Ctx> {
+impl<Pk: Key, Ctx: Context> AstElemExt<Pk, Ctx> {
     /// Compute a 1-dimensional cost, given a probability of satisfaction
     /// and a probability of dissatisfaction; if `dissat_prob` is `None`
     /// then it is assumed that dissatisfaction never occurs
@@ -477,7 +477,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> AstElemExt<Pk, Ctx> {
     }
 }
 
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> AstElemExt<Pk, Ctx> {
+impl<Pk: Key, Ctx: Context> AstElemExt<Pk, Ctx> {
     fn terminal(ast: Terminal<Pk, Ctx>) -> AstElemExt<Pk, Ctx> {
         AstElemExt {
             comp_ext_data: CompilerExtData::type_check(&ast, |_| None).unwrap(),
@@ -533,14 +533,14 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> AstElemExt<Pk, Ctx> {
 /// Different types of casts possible for each node.
 #[allow(clippy::type_complexity)]
 #[derive(Copy, Clone)]
-struct Cast<Pk: MiniscriptKey, Ctx: ScriptContext> {
+struct Cast<Pk: Key, Ctx: Context> {
     node: fn(Arc<Miniscript<Pk, Ctx>>) -> Terminal<Pk, Ctx>,
     ast_type: fn(types::Type) -> Result<types::Type, ErrorKind>,
     ext_data: fn(types::ExtData) -> Result<types::ExtData, ErrorKind>,
     comp_ext_data: fn(CompilerExtData) -> Result<CompilerExtData, types::ErrorKind>,
 }
 
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> Cast<Pk, Ctx> {
+impl<Pk: Key, Ctx: Context> Cast<Pk, Ctx> {
     fn cast(&self, ast: &AstElemExt<Pk, Ctx>) -> Result<AstElemExt<Pk, Ctx>, ErrorKind> {
         Ok(AstElemExt {
             ms: Arc::new(Miniscript::from_components_unchecked(
@@ -553,7 +553,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Cast<Pk, Ctx> {
     }
 }
 
-fn all_casts<Pk: MiniscriptKey, Ctx: ScriptContext>() -> [Cast<Pk, Ctx>; 10] {
+fn all_casts<Pk: Key, Ctx: Context>() -> [Cast<Pk, Ctx>; 10] {
     [
         Cast {
             ext_data: types::ExtData::cast_check,
@@ -647,7 +647,7 @@ fn all_casts<Pk: MiniscriptKey, Ctx: ScriptContext>() -> [Cast<Pk, Ctx>; 10] {
 /// the map.
 /// In general, we maintain the invariant that if anything is inserted into the
 /// map, it's cast closure must also be considered for best compilations.
-fn insert_elem<Pk: MiniscriptKey, Ctx: ScriptContext>(
+fn insert_elem<Pk: Key, Ctx: Context>(
     map: &mut BTreeMap<CompilationKey, AstElemExt<Pk, Ctx>>,
     elem: AstElemExt<Pk, Ctx>,
     sat_prob: f64,
@@ -700,7 +700,7 @@ fn insert_elem<Pk: MiniscriptKey, Ctx: ScriptContext>(
 /// At the start and end of this function, we maintain that the invariant that
 /// all map is smallest possible closure of all compilations of a policy with
 /// given sat and dissat probabilities.
-fn insert_elem_closure<Pk: MiniscriptKey, Ctx: ScriptContext>(
+fn insert_elem_closure<Pk: Key, Ctx: Context>(
     map: &mut BTreeMap<CompilationKey, AstElemExt<Pk, Ctx>>,
     astelem_ext: AstElemExt<Pk, Ctx>,
     sat_prob: f64,
@@ -734,7 +734,7 @@ fn insert_elem_closure<Pk: MiniscriptKey, Ctx: ScriptContext>(
 /// given that it may be not be necessary to dissatisfy. For these elements, we
 /// apply the wrappers around the element once and bring them into the same
 /// dissat probability map and get their closure.
-fn insert_best_wrapped<Pk: MiniscriptKey, Ctx: ScriptContext>(
+fn insert_best_wrapped<Pk: Key, Ctx: Context>(
     policy_cache: &mut PolicyCache<Pk, Ctx>,
     policy: &Concrete<Pk>,
     map: &mut BTreeMap<CompilationKey, AstElemExt<Pk, Ctx>>,
@@ -767,8 +767,8 @@ fn best_compilations<Pk, Ctx>(
     dissat_prob: Option<f64>,
 ) -> Result<BTreeMap<CompilationKey, AstElemExt<Pk, Ctx>>, CompilerError>
 where
-    Pk: MiniscriptKey,
-    Ctx: ScriptContext,
+    Pk: Key,
+    Ctx: Context,
 {
     //Check the cache for hits
     let ord_sat_prob = OrdF64(sat_prob);
@@ -1068,8 +1068,8 @@ fn compile_binary<Pk, Ctx, F>(
     bin_func: F,
 ) -> Result<(), CompilerError>
 where
-    Pk: MiniscriptKey,
-    Ctx: ScriptContext,
+    Pk: Key,
+    Ctx: Context,
     F: Fn(Arc<Miniscript<Pk, Ctx>>, Arc<Miniscript<Pk, Ctx>>) -> Terminal<Pk, Ctx>,
 {
     for l in left_comp.values_mut() {
@@ -1091,7 +1091,7 @@ where
 /// `sat_prob` and `dissat_prob` represent the sat and dissat probabilities of
 /// root and_or node. `weights` represent the odds for taking each sub branch
 #[allow(clippy::too_many_arguments)]
-fn compile_tern<Pk: MiniscriptKey, Ctx: ScriptContext>(
+fn compile_tern<Pk: Key, Ctx: Context>(
     policy_cache: &mut PolicyCache<Pk, Ctx>,
     policy: &Concrete<Pk>,
     ret: &mut BTreeMap<CompilationKey, AstElemExt<Pk, Ctx>>,
@@ -1122,7 +1122,7 @@ fn compile_tern<Pk: MiniscriptKey, Ctx: ScriptContext>(
 }
 
 /// Obtain the best compilation of for p=1.0 and q=0
-pub fn best_compilation<Pk: MiniscriptKey, Ctx: ScriptContext>(
+pub fn best_compilation<Pk: Key, Ctx: Context>(
     policy: &Concrete<Pk>,
 ) -> Result<Miniscript<Pk, Ctx>, CompilerError> {
     let mut policy_cache = PolicyCache::<Pk, Ctx>::new();
@@ -1144,8 +1144,8 @@ fn best_t<Pk, Ctx>(
     dissat_prob: Option<f64>,
 ) -> Result<AstElemExt<Pk, Ctx>, CompilerError>
 where
-    Pk: MiniscriptKey,
-    Ctx: ScriptContext,
+    Pk: Key,
+    Ctx: Context,
 {
     best_compilations(policy_cache, policy, sat_prob, dissat_prob)?
         .into_iter()
@@ -1166,8 +1166,8 @@ fn best<Pk, Ctx>(
     dissat_prob: Option<f64>,
 ) -> Result<AstElemExt<Pk, Ctx>, CompilerError>
 where
-    Pk: MiniscriptKey,
-    Ctx: ScriptContext,
+    Pk: Key,
+    Ctx: Context,
 {
     best_compilations(policy_cache, policy, sat_prob, dissat_prob)?
         .into_iter()
diff --git a/src/policy/concrete.rs b/src/policy/concrete.rs
index d030a99d2..ae7c6458d 100644
--- a/src/policy/concrete.rs
+++ b/src/policy/concrete.rs
@@ -11,7 +11,7 @@ use bitcoin::{absolute, Sequence};
 #[cfg(feature = "compiler")]
 use {
     crate::descriptor::TapTree,
-    crate::miniscript::ScriptContext,
+    crate::miniscript::Context,
     crate::policy::compiler::CompilerError,
     crate::policy::compiler::OrdF64,
     crate::policy::{compiler, Concrete, Liftable, Semantic},
@@ -28,7 +28,7 @@ use crate::miniscript::types::extra_props::TimelockInfo;
 use crate::prelude::*;
 #[cfg(all(doc, not(feature = "compiler")))]
 use crate::Descriptor;
-use crate::{errstr, AbsLockTime, Error, ForEachKey, MiniscriptKey, Translator};
+use crate::{errstr, AbsLockTime, Error, ForEachKey, Key, Translator};
 
 /// Maximum TapLeafs allowed in a compiled TapTree
 #[cfg(feature = "compiler")]
@@ -38,7 +38,7 @@ const MAX_COMPILATION_LEAVES: usize = 1024;
 /// and whose disjunctions are annotated with satisfaction probabilities
 /// to assist the compiler.
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum Policy<Pk: MiniscriptKey> {
+pub enum Policy<Pk: Key> {
     /// Unsatisfiable.
     Unsatisfiable,
     /// Trivially satisfiable.
@@ -68,7 +68,7 @@ pub enum Policy<Pk: MiniscriptKey> {
 
 impl<Pk> Policy<Pk>
 where
-    Pk: MiniscriptKey,
+    Pk: Key,
 {
     /// Construct a `Policy::After` from `n`. Helper function equivalent to
     /// `Policy::After(absolute::LockTime::from_consensus(n))`.
@@ -88,7 +88,7 @@ where
 /// probabilities to assist the compiler
 #[cfg(feature = "compiler")]
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-enum PolicyArc<Pk: MiniscriptKey> {
+enum PolicyArc<Pk: Key> {
     /// Unsatisfiable
     Unsatisfiable,
     /// Trivially satisfiable
@@ -117,7 +117,7 @@ enum PolicyArc<Pk: MiniscriptKey> {
 }
 
 #[cfg(feature = "compiler")]
-impl<Pk: MiniscriptKey> From<PolicyArc<Pk>> for Policy<Pk> {
+impl<Pk: Key> From<PolicyArc<Pk>> for Policy<Pk> {
     fn from(p: PolicyArc<Pk>) -> Self {
         match p {
             PolicyArc::Unsatisfiable => Policy::Unsatisfiable,
@@ -150,7 +150,7 @@ impl<Pk: MiniscriptKey> From<PolicyArc<Pk>> for Policy<Pk> {
 }
 
 #[cfg(feature = "compiler")]
-impl<Pk: MiniscriptKey> From<Policy<Pk>> for PolicyArc<Pk> {
+impl<Pk: Key> From<Policy<Pk>> for PolicyArc<Pk> {
     fn from(p: Policy<Pk>) -> Self {
         match p {
             Policy::Unsatisfiable => PolicyArc::Unsatisfiable,
@@ -275,7 +275,7 @@ impl error::Error for PolicyError {
     }
 }
 
-impl<Pk: MiniscriptKey> Policy<Pk> {
+impl<Pk: Key> Policy<Pk> {
     /// Flattens the [`Policy`] tree structure into a vector of tuples `(leaf script, leaf probability)`
     /// with leaf probabilities corresponding to odds for each sub-branch in the policy.
     /// We calculate the probability of selecting the sub-branch at every level and calculate the
@@ -483,7 +483,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
     /// use the policy compiler once, and then use the miniscript output as a stable identifier. See
     /// the compiler document in [`doc/compiler.md`] for more details.
     #[cfg(feature = "compiler")]
-    pub fn compile_to_descriptor<Ctx: ScriptContext>(
+    pub fn compile_to_descriptor<Ctx: Context>(
         &self,
         desc_ctx: DescriptorCtx<Pk>,
     ) -> Result<Descriptor<Pk>, Error> {
@@ -511,7 +511,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
     /// use the policy compiler once, and then use the miniscript output as a stable identifier. See
     /// the compiler document in doc/compiler.md for more details.
     #[cfg(feature = "compiler")]
-    pub fn compile<Ctx: ScriptContext>(&self) -> Result<Miniscript<Pk, Ctx>, CompilerError> {
+    pub fn compile<Ctx: Context>(&self) -> Result<Miniscript<Pk, Ctx>, CompilerError> {
         self.is_valid()?;
         match self.is_safe_nonmalleable() {
             (false, _) => Err(CompilerError::TopLevelNonSafe),
@@ -522,7 +522,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
 }
 
 #[cfg(feature = "compiler")]
-impl<Pk: MiniscriptKey> PolicyArc<Pk> {
+impl<Pk: Key> PolicyArc<Pk> {
     /// Returns a vector of policies whose disjunction is isomorphic to the initial one.
     ///
     /// This function is supposed to incrementally expand i.e. represent the policy as
@@ -654,13 +654,13 @@ impl<Pk: MiniscriptKey> PolicyArc<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey> ForEachKey<Pk> for Policy<Pk> {
+impl<Pk: Key> ForEachKey<Pk> for Policy<Pk> {
     fn for_each_key<'a, F: FnMut(&'a Pk) -> bool>(&'a self, mut pred: F) -> bool {
         self.real_for_each_key(&mut pred)
     }
 }
 
-impl<Pk: MiniscriptKey> Policy<Pk> {
+impl<Pk: Key> Policy<Pk> {
     fn real_for_each_key<'a, F: FnMut(&'a Pk) -> bool>(&'a self, pred: &mut F) -> bool {
         match *self {
             Policy::Unsatisfiable | Policy::Trivial => true,
@@ -686,7 +686,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
     pub fn translate_pk<Q, E, T>(&self, t: &mut T) -> Result<Policy<Q>, E>
     where
         T: Translator<Pk, Q, E>,
-        Q: MiniscriptKey,
+        Q: Key,
     {
         self._translate_pk(t)
     }
@@ -694,7 +694,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
     fn _translate_pk<Q, E, T>(&self, t: &mut T) -> Result<Policy<Q>, E>
     where
         T: Translator<Pk, Q, E>,
-        Q: MiniscriptKey,
+        Q: Key,
     {
         match *self {
             Policy::Unsatisfiable => Ok(Policy::Unsatisfiable),
@@ -970,7 +970,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey> fmt::Debug for Policy<Pk> {
+impl<Pk: Key> fmt::Debug for Policy<Pk> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             Policy::Unsatisfiable => f.write_str("UNSATISFIABLE()"),
@@ -1013,7 +1013,7 @@ impl<Pk: MiniscriptKey> fmt::Debug for Policy<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey> fmt::Display for Policy<Pk> {
+impl<Pk: Key> fmt::Display for Policy<Pk> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             Policy::Unsatisfiable => f.write_str("UNSATISFIABLE"),
@@ -1187,7 +1187,7 @@ impl_from_tree!(
 
 /// Creates a Huffman Tree from compiled [`Miniscript`] nodes.
 #[cfg(feature = "compiler")]
-fn with_huffman_tree<Pk: MiniscriptKey>(
+fn with_huffman_tree<Pk: Key>(
     ms: Vec<(OrdF64, Miniscript<Pk, Tap>)>,
 ) -> Result<TapTree<Pk>, Error> {
     let mut node_weights = BinaryHeap::<(Reverse<OrdF64>, TapTree<Pk>)>::new();
@@ -1221,7 +1221,7 @@ fn with_huffman_tree<Pk: MiniscriptKey>(
 /// by the simple argument that choosing `k` conditions from `n` available conditions might not contain
 /// any one of the conditions exclusively.
 #[cfg(feature = "compiler")]
-fn generate_combination<Pk: MiniscriptKey>(
+fn generate_combination<Pk: Key>(
     policy_vec: &Vec<Arc<PolicyArc<Pk>>>,
     prob: f64,
     k: usize,
diff --git a/src/policy/mod.rs b/src/policy/mod.rs
index 27165c2e2..c9423b296 100644
--- a/src/policy/mod.rs
+++ b/src/policy/mod.rs
@@ -21,8 +21,8 @@ pub mod semantic;
 pub use self::concrete::Policy as Concrete;
 pub use self::semantic::Policy as Semantic;
 use crate::descriptor::Descriptor;
-use crate::miniscript::{Miniscript, ScriptContext};
-use crate::{Error, MiniscriptKey, Terminal};
+use crate::miniscript::{Context, Miniscript};
+use crate::{Error, Key, Terminal};
 
 /// Policy entailment algorithm maximum number of terminals allowed.
 const ENTAILMENT_MAX_TERMINALS: usize = 20;
@@ -43,7 +43,7 @@ const ENTAILMENT_MAX_TERMINALS: usize = 20;
 /// exceed resource limits for any compilation but cannot detect such policies
 /// while lifting. Note that our compiler would not succeed for any such
 /// policies.
-pub trait Liftable<Pk: MiniscriptKey> {
+pub trait Liftable<Pk: Key> {
     /// Converts this object into an abstract policy.
     fn lift(&self) -> Result<Semantic<Pk>, Error>;
 }
@@ -84,7 +84,7 @@ impl error::Error for LiftError {
     }
 }
 
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
+impl<Pk: Key, Ctx: Context> Miniscript<Pk, Ctx> {
     /// Lifting corresponds to conversion of a miniscript into a [`Semantic`]
     /// policy for human readable or machine analysis. However, naively lifting
     /// miniscripts can result in incorrect interpretations that don't
@@ -103,7 +103,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
     }
 }
 
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> Liftable<Pk> for Miniscript<Pk, Ctx> {
+impl<Pk: Key, Ctx: Context> Liftable<Pk> for Miniscript<Pk, Ctx> {
     fn lift(&self) -> Result<Semantic<Pk>, Error> {
         // check whether the root miniscript can have a spending path that is
         // a combination of heightlock and timelock
@@ -112,7 +112,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Liftable<Pk> for Miniscript<Pk, Ctx>
     }
 }
 
-impl<Pk: MiniscriptKey, Ctx: ScriptContext> Liftable<Pk> for Terminal<Pk, Ctx> {
+impl<Pk: Key, Ctx: Context> Liftable<Pk> for Terminal<Pk, Ctx> {
     fn lift(&self) -> Result<Semantic<Pk>, Error> {
         let ret = match *self {
             Terminal::PkK(ref pk) | Terminal::PkH(ref pk) => Semantic::Key(pk.clone()),
@@ -163,7 +163,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Liftable<Pk> for Terminal<Pk, Ctx> {
     }
 }
 
-impl<Pk: MiniscriptKey> Liftable<Pk> for Descriptor<Pk> {
+impl<Pk: Key> Liftable<Pk> for Descriptor<Pk> {
     fn lift(&self) -> Result<Semantic<Pk>, Error> {
         match *self {
             Descriptor::Bare(ref bare) => bare.lift(),
@@ -176,13 +176,13 @@ impl<Pk: MiniscriptKey> Liftable<Pk> for Descriptor<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey> Liftable<Pk> for Semantic<Pk> {
+impl<Pk: Key> Liftable<Pk> for Semantic<Pk> {
     fn lift(&self) -> Result<Semantic<Pk>, Error> {
         Ok(self.clone())
     }
 }
 
-impl<Pk: MiniscriptKey> Liftable<Pk> for Concrete<Pk> {
+impl<Pk: Key> Liftable<Pk> for Concrete<Pk> {
     fn lift(&self) -> Result<Semantic<Pk>, Error> {
         // do not lift if there is a possible satisfaction
         // involving combination of timelocks and heightlocks
diff --git a/src/policy/semantic.rs b/src/policy/semantic.rs
index aa2de8680..1d2dc44f7 100644
--- a/src/policy/semantic.rs
+++ b/src/policy/semantic.rs
@@ -13,7 +13,7 @@ use bitcoin::{absolute, Sequence};
 use super::concrete::PolicyError;
 use super::ENTAILMENT_MAX_TERMINALS;
 use crate::prelude::*;
-use crate::{errstr, expression, AbsLockTime, Error, ForEachKey, MiniscriptKey, Translator};
+use crate::{errstr, expression, AbsLockTime, Error, ForEachKey, Key, Translator};
 
 /// Abstract policy which corresponds to the semantics of a miniscript and
 /// which allows complex forms of analysis, e.g. filtering and normalization.
@@ -22,7 +22,7 @@ use crate::{errstr, expression, AbsLockTime, Error, ForEachKey, MiniscriptKey, T
 /// representing the same policy are lifted to the same abstract `Policy`,
 /// regardless of their choice of `pk` or `pk_h` nodes.
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord)]
-pub enum Policy<Pk: MiniscriptKey> {
+pub enum Policy<Pk: Key> {
     /// Unsatisfiable.
     Unsatisfiable,
     /// Trivially satisfiable.
@@ -47,7 +47,7 @@ pub enum Policy<Pk: MiniscriptKey> {
 
 impl<Pk> Policy<Pk>
 where
-    Pk: MiniscriptKey,
+    Pk: Key,
 {
     /// Constructs a `Policy::After` from `n`.
     ///
@@ -64,13 +64,13 @@ where
     }
 }
 
-impl<Pk: MiniscriptKey> ForEachKey<Pk> for Policy<Pk> {
+impl<Pk: Key> ForEachKey<Pk> for Policy<Pk> {
     fn for_each_key<'a, F: FnMut(&'a Pk) -> bool>(&'a self, mut pred: F) -> bool {
         self.real_for_each_key(&mut pred)
     }
 }
 
-impl<Pk: MiniscriptKey> Policy<Pk> {
+impl<Pk: Key> Policy<Pk> {
     fn real_for_each_key<'a, F: FnMut(&'a Pk) -> bool>(&'a self, pred: &mut F) -> bool {
         match *self {
             Policy::Unsatisfiable | Policy::Trivial => true,
@@ -131,7 +131,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
     pub fn translate_pk<Q, E, T>(&self, t: &mut T) -> Result<Policy<Q>, E>
     where
         T: Translator<Pk, Q, E>,
-        Q: MiniscriptKey,
+        Q: Key,
     {
         self._translate_pk(t)
     }
@@ -139,7 +139,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
     fn _translate_pk<Q, E, T>(&self, t: &mut T) -> Result<Policy<Q>, E>
     where
         T: Translator<Pk, Q, E>,
-        Q: MiniscriptKey,
+        Q: Key,
     {
         match *self {
             Policy::Unsatisfiable => Ok(Policy::Unsatisfiable),
@@ -244,7 +244,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey> fmt::Debug for Policy<Pk> {
+impl<Pk: Key> fmt::Debug for Policy<Pk> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             Policy::Unsatisfiable => f.write_str("UNSATISFIABLE()"),
@@ -277,7 +277,7 @@ impl<Pk: MiniscriptKey> fmt::Debug for Policy<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey> fmt::Display for Policy<Pk> {
+impl<Pk: Key> fmt::Display for Policy<Pk> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             Policy::Unsatisfiable => f.write_str("UNSATISFIABLE"),
@@ -400,7 +400,7 @@ impl_from_tree!(
     }
 );
 
-impl<Pk: MiniscriptKey> Policy<Pk> {
+impl<Pk: Key> Policy<Pk> {
     /// Flattens out trees of `And`s and `Or`s; eliminate `Trivial` and
     /// `Unsatisfiable`s. Does not reorder any branches; use `.sort`.
     pub fn normalized(self) -> Policy<Pk> {
@@ -627,7 +627,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
     }
 }
 
-impl<Pk: MiniscriptKey> Policy<Pk> {
+impl<Pk: Key> Policy<Pk> {
     /// "Sorts" a policy to bring it into a canonical form to allow comparisons.
     ///
     /// Does **not** allow policies to be compared for functional equivalence;
diff --git a/src/psbt/mod.rs b/src/psbt/mod.rs
index 1668f2f66..8905cb4dc 100644
--- a/src/psbt/mod.rs
+++ b/src/psbt/mod.rs
@@ -22,7 +22,7 @@ use bitcoin::{absolute, bip32, Script, ScriptBuf, Sequence};
 use crate::miniscript::context::SigType;
 use crate::prelude::*;
 use crate::{
-    descriptor, interpreter, DefiniteDescriptorKey, Descriptor, DescriptorPublicKey, MiniscriptKey,
+    descriptor, interpreter, DefiniteDescriptorKey, Descriptor, DescriptorPublicKey, Key,
     Preimage32, Satisfier, ToPublicKey, TranslatePk, Translator,
 };
 
@@ -271,7 +271,7 @@ impl<'psbt> PsbtInputSatisfier<'psbt> {
     }
 }
 
-impl<'psbt, Pk: MiniscriptKey + ToPublicKey> Satisfier<Pk> for PsbtInputSatisfier<'psbt> {
+impl<'psbt, Pk: Key + ToPublicKey> Satisfier<Pk> for PsbtInputSatisfier<'psbt> {
     fn lookup_tap_key_spend_sig(&self) -> Option<bitcoin::taproot::Signature> {
         self.psbt.inputs[self.index].tap_key_sig
     }
diff --git a/src/pub_macros.rs b/src/pub_macros.rs
index bdb0d59b4..5e3ccbecb 100644
--- a/src/pub_macros.rs
+++ b/src/pub_macros.rs
@@ -47,29 +47,29 @@ macro_rules! translate_hash_fail {
     ($source: ty, $target:ty, $error_ty: ty) => {
         fn sha256(
             &mut self,
-            _sha256: &<$source as $crate::MiniscriptKey>::Sha256,
-        ) -> Result<<$target as $crate::MiniscriptKey>::Sha256, $error_ty> {
+            _sha256: &<$source as $crate::Key>::Sha256,
+        ) -> Result<<$target as $crate::Key>::Sha256, $error_ty> {
             panic!("Called sha256 on translate_only_pk")
         }
 
         fn hash256(
             &mut self,
-            _hash256: &<$source as $crate::MiniscriptKey>::Hash256,
-        ) -> Result<<$target as $crate::MiniscriptKey>::Hash256, $error_ty> {
+            _hash256: &<$source as $crate::Key>::Hash256,
+        ) -> Result<<$target as $crate::Key>::Hash256, $error_ty> {
             panic!("Called hash256 on translate_only_pk")
         }
 
         fn hash160(
             &mut self,
-            _hash160: &<$source as $crate::MiniscriptKey>::Hash160,
-        ) -> Result<<$target as $crate::MiniscriptKey>::Hash160, $error_ty> {
+            _hash160: &<$source as $crate::Key>::Hash160,
+        ) -> Result<<$target as $crate::Key>::Hash160, $error_ty> {
             panic!("Called hash160 on translate_only_pk")
         }
 
         fn ripemd160(
             &mut self,
-            _ripemd160: &<$source as $crate::MiniscriptKey>::Ripemd160,
-        ) -> Result<<$target as $crate::MiniscriptKey>::Ripemd160, $error_ty> {
+            _ripemd160: &<$source as $crate::Key>::Ripemd160,
+        ) -> Result<<$target as $crate::Key>::Ripemd160, $error_ty> {
             panic!("Called ripemd160 on translate_only_pk")
         }
     };
@@ -88,29 +88,29 @@ macro_rules! translate_hash_clone {
     ($source: ty, $target:ty, $error_ty: ty) => {
         fn sha256(
             &mut self,
-            sha256: &<$source as $crate::MiniscriptKey>::Sha256,
-        ) -> Result<<$target as $crate::MiniscriptKey>::Sha256, $error_ty> {
+            sha256: &<$source as $crate::Key>::Sha256,
+        ) -> Result<<$target as $crate::Key>::Sha256, $error_ty> {
             Ok((*sha256).into())
         }
 
         fn hash256(
             &mut self,
-            hash256: &<$source as $crate::MiniscriptKey>::Hash256,
-        ) -> Result<<$target as $crate::MiniscriptKey>::Hash256, $error_ty> {
+            hash256: &<$source as $crate::Key>::Hash256,
+        ) -> Result<<$target as $crate::Key>::Hash256, $error_ty> {
             Ok((*hash256).into())
         }
 
         fn hash160(
             &mut self,
-            hash160: &<$source as $crate::MiniscriptKey>::Hash160,
-        ) -> Result<<$target as $crate::MiniscriptKey>::Hash160, $error_ty> {
+            hash160: &<$source as $crate::Key>::Hash160,
+        ) -> Result<<$target as $crate::Key>::Hash160, $error_ty> {
             Ok((*hash160).into())
         }
 
         fn ripemd160(
             &mut self,
-            ripemd160: &<$source as $crate::MiniscriptKey>::Ripemd160,
-        ) -> Result<<$target as $crate::MiniscriptKey>::Ripemd160, $error_ty> {
+            ripemd160: &<$source as $crate::Key>::Ripemd160,
+        ) -> Result<<$target as $crate::Key>::Ripemd160, $error_ty> {
             Ok((*ripemd160).into())
         }
     };
diff --git a/src/test_utils.rs b/src/test_utils.rs
index dea8aae58..329ea0de1 100644
--- a/src/test_utils.rs
+++ b/src/test_utils.rs
@@ -12,7 +12,7 @@ use bitcoin::secp256k1;
 use crate::miniscript::context::SigType;
 use crate::{hash256, ToPublicKey, Translator};
 
-/// Translate from a String MiniscriptKey type to bitcoin::PublicKey
+/// Translate from a String Key type to bitcoin::PublicKey
 /// If the hashmap is populated, this will lookup for keys in HashMap
 /// Otherwise, this will return a translation to a random key
 #[derive(Debug, PartialEq, Eq, Clone)]
diff --git a/src/util.rs b/src/util.rs
index 0564108a3..5469ef7e8 100644
--- a/src/util.rs
+++ b/src/util.rs
@@ -8,7 +8,7 @@ use bitcoin::PubkeyHash;
 
 use crate::miniscript::context;
 use crate::prelude::*;
-use crate::{ScriptContext, ToPublicKey};
+use crate::{Context, ToPublicKey};
 pub(crate) fn varint_len(n: usize) -> usize {
     bitcoin::VarInt(n as u64).len()
 }
@@ -38,20 +38,20 @@ pub(crate) trait MsKeyBuilder {
     fn push_ms_key<Pk, Ctx>(self, key: &Pk) -> Self
     where
         Pk: ToPublicKey,
-        Ctx: ScriptContext;
+        Ctx: Context;
 
     /// Serialize the key hash as bytes based on script context. Used when encoding miniscript into bitcoin script
     fn push_ms_key_hash<Pk, Ctx>(self, key: &Pk) -> Self
     where
         Pk: ToPublicKey,
-        Ctx: ScriptContext;
+        Ctx: Context;
 }
 
 impl MsKeyBuilder for script::Builder {
     fn push_ms_key<Pk, Ctx>(self, key: &Pk) -> Self
     where
         Pk: ToPublicKey,
-        Ctx: ScriptContext,
+        Ctx: Context,
     {
         match Ctx::sig_type() {
             context::SigType::Ecdsa => self.push_key(&key.to_public_key()),
@@ -62,7 +62,7 @@ impl MsKeyBuilder for script::Builder {
     fn push_ms_key_hash<Pk, Ctx>(self, key: &Pk) -> Self
     where
         Pk: ToPublicKey,
-        Ctx: ScriptContext,
+        Ctx: Context,
     {
         match Ctx::sig_type() {
             context::SigType::Ecdsa => self.push_slice(key.to_public_key().pubkey_hash()),