diff --git a/Cargo.toml b/Cargo.toml
index 2a1e3a690..bb64eede9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "sapio-miniscript"
-version = "7.0.1"
+version = "7.0.2-alpha.0"
 authors = ["Jeremy Rubin <jeremy.l.rubin@gmail.com>", "Andrew Poelstra <apoelstra@wpsoftware.net>, Sanket Kanjalkar <sanket1729@gmail.com>"]
 repository = "https://github.com/sapio-lang/rust-miniscript"
 description = "Miniscript: a subset of Bitcoin Script designed for analysis, Sapio extended edition (supports BIP-119 OP_CTV)"
@@ -25,6 +25,7 @@ optional = true
 [dependencies.serde]
 version = "1.0"
 optional = true
+features = ["derive"]
 
 [[example]]
 name = "htlc"
diff --git a/src/interpreter/mod.rs b/src/interpreter/mod.rs
index 56159939b..f1e7be2e3 100644
--- a/src/interpreter/mod.rs
+++ b/src/interpreter/mod.rs
@@ -1052,7 +1052,7 @@ mod tests {
     use super::*;
     use bitcoin;
     use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d, Hash};
-    use bitcoin::secp256k1::{self, Secp256k1};
+    use bitcoin::secp256k1::{self, Secp256k1, Parity};
     use miniscript::context::NoChecks;
     use Miniscript;
     use MiniscriptKey;
@@ -1066,7 +1066,7 @@ mod tests {
         Vec<bitcoin::EcdsaSig>,
         secp256k1::Message,
         Secp256k1<secp256k1::All>,
-        Vec<bitcoin::XOnlyPublicKey>,
+        Vec<(bitcoin::XOnlyPublicKey, Parity)>,
         Vec<bitcoin::SchnorrSig>,
         Vec<Vec<u8>>,
     ) {
@@ -1101,7 +1101,7 @@ mod tests {
             pks.push(pk);
             der_sigs.push(sigser);
 
-            let keypair = bitcoin::KeyPair::from_secret_key(&secp, sk);
+            let keypair = bitcoin::KeyPair::from_secret_key(&secp, &sk);
             x_only_pks.push(bitcoin::XOnlyPublicKey::from_keypair(&keypair));
             let schnorr_sig = secp.sign_schnorr_with_aux_rand(&msg, &keypair, &[0u8; 32]);
             let schnorr_sig = bitcoin::SchnorrSig {
@@ -1568,7 +1568,7 @@ mod tests {
 
         let elem = x_only_no_checks_ms(&format!(
             "multi_a(3,{},{},{},{},{})",
-            xpks[0], xpks[1], xpks[2], xpks[3], xpks[4],
+            xpks[0].0, xpks[1].0, xpks[2].0, xpks[3].0, xpks[4].0,
         ));
         let vfyfn = vfyfn_.clone(); // sigh rust 1.29...
         let constraints = from_stack(Box::new(vfyfn), txtmpl_hash, stack, &elem);
@@ -1578,13 +1578,13 @@ mod tests {
             multi_a_satisfied.unwrap(),
             vec![
                 SatisfiedConstraint::PublicKey {
-                    key_sig: KeySigPair::Schnorr(xpks[0], schnorr_sigs[0])
+                    key_sig: KeySigPair::Schnorr(xpks[0].0, schnorr_sigs[0])
                 },
                 SatisfiedConstraint::PublicKey {
-                    key_sig: KeySigPair::Schnorr(xpks[1], schnorr_sigs[1])
+                    key_sig: KeySigPair::Schnorr(xpks[1].0, schnorr_sigs[1])
                 },
                 SatisfiedConstraint::PublicKey {
-                    key_sig: KeySigPair::Schnorr(xpks[2], schnorr_sigs[2])
+                    key_sig: KeySigPair::Schnorr(xpks[2].0, schnorr_sigs[2])
                 },
             ]
         );
@@ -1600,7 +1600,7 @@ mod tests {
 
         let elem = x_only_no_checks_ms(&format!(
             "multi_a(3,{},{},{},{},{})",
-            xpks[0], xpks[1], xpks[2], xpks[3], xpks[4],
+            xpks[0].0, xpks[1].0, xpks[2].0, xpks[3].0, xpks[4].0,
         ));
         let vfyfn = vfyfn_.clone(); // sigh rust 1.29...
         let constraints = from_stack(Box::new(vfyfn), txtmpl_hash, stack.clone(), &elem);
@@ -1611,7 +1611,7 @@ mod tests {
         // multi_a wrong thresh: k = 2, but three sigs
         let elem = x_only_no_checks_ms(&format!(
             "multi_a(2,{},{},{},{},{})",
-            xpks[0], xpks[1], xpks[2], xpks[3], xpks[4],
+            xpks[0].0, xpks[1].0, xpks[2].0, xpks[3].0, xpks[4].0,
         ));
         let vfyfn = vfyfn_.clone(); // sigh rust 1.29...
         let constraints = from_stack(Box::new(vfyfn), txtmpl_hash, stack.clone(), &elem);
@@ -1622,7 +1622,7 @@ mod tests {
         // multi_a correct thresh, but small stack
         let elem = x_only_no_checks_ms(&format!(
             "multi_a(3,{},{},{},{},{},{})",
-            xpks[0], xpks[1], xpks[2], xpks[3], xpks[4], xpks[5]
+            xpks[0].0, xpks[1].0, xpks[2].0, xpks[3].0, xpks[4].0, xpks[5].0
         ));
         let vfyfn = vfyfn_.clone(); // sigh rust 1.29...
         let constraints = from_stack(Box::new(vfyfn), txtmpl_hash, stack, &elem);
diff --git a/src/lib.rs b/src/lib.rs
index 639541859..f972eaa3a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -115,6 +115,8 @@ pub mod interpreter;
 pub mod miniscript;
 pub mod policy;
 pub mod psbt;
+#[allow(missing_docs)]
+pub mod ord;
 
 mod util;
 
@@ -597,6 +599,8 @@ pub enum Error {
     TrNoScriptCode,
     /// No explicit script for Tr descriptors
     TrNoExplicitScript,
+    /// Inscription System Issue
+    InscriptionError(String)
 }
 
 #[doc(hidden)]
@@ -737,6 +741,8 @@ impl fmt::Display for Error {
             Error::TrNoExplicitScript => {
                 write!(f, "No script code for Tr descriptors")
             }
+            Error::InscriptionError(ref s) => 
+                write!(f, "Inscription Error: {}", s)
         }
     }
 }
diff --git a/src/miniscript/astelem.rs b/src/miniscript/astelem.rs
index 9caca84ad..741df381d 100644
--- a/src/miniscript/astelem.rs
+++ b/src/miniscript/astelem.rs
@@ -23,9 +23,11 @@ use std::str::FromStr;
 use std::sync::Arc;
 use std::{fmt, str};
 
+use bitcoin::blockdata::script::Builder;
 use bitcoin::blockdata::{opcodes, script};
 use bitcoin::hashes::hex::FromHex;
 use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d, Hash};
+use bitcoin::Script;
 
 use errstr;
 use expression;
@@ -35,6 +37,9 @@ use miniscript::ScriptContext;
 use script_num_size;
 
 use util::MsKeyBuilder;
+
+use crate::ord::envelope::{Envelope, ParsedEnvelope};
+use crate::ord::Inscription;
 use {Error, ForEach, ForEachKey, Miniscript, MiniscriptKey, Terminal, ToPublicKey, TranslatePk};
 
 impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
@@ -124,6 +129,9 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
             Terminal::Multi(_, ref keys) | Terminal::MultiA(_, ref keys) => {
                 keys.iter().all(|key| pred(ForEach::Key(key)))
             }
+            Terminal::InscribePre(_, ref m) | Terminal::InscribePost(_, ref m) => {
+                m.real_for_each_key(pred)
+            }
         }
     }
     pub(super) fn real_translate_pk<FPk, FPkh, Q, Error, CtxQ>(
@@ -219,6 +227,14 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
                 Terminal::MultiA(k, keys?)
             }
             Terminal::TxTemplate(x) => Terminal::TxTemplate(x),
+            Terminal::InscribePre(ref a, ref b) => Terminal::InscribePre(
+                a.clone(),
+                Arc::new(b.real_translate_pk(translatefpk, translatefpkh)?),
+            ),
+            Terminal::InscribePost(ref a, ref b) => Terminal::InscribePost(
+                a.clone(),
+                Arc::new(b.real_translate_pk(translatefpk, translatefpkh)?),
+            ),
         };
         Ok(frag)
     }
@@ -341,6 +357,24 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> fmt::Debug for Terminal<Pk, Ctx> {
 impl<Pk: MiniscriptKey, Ctx: ScriptContext> fmt::Display for Terminal<Pk, Ctx> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
+            Terminal::InscribePost(ref insc, ref sub) => {
+                let script = insc
+                    .iter()
+                    .fold(Builder::new(), |builder, i| {
+                        i.append_reveal_script_to_builder(builder)
+                    })
+                    .into_script();
+                write!(f, "inscribe_post({:x},{})", script, sub)
+            }
+            Terminal::InscribePre(ref insc, ref sub) => {
+                let script = insc
+                    .iter()
+                    .fold(Builder::new(), |builder, i| {
+                        i.append_reveal_script_to_builder(builder)
+                    })
+                    .into_script();
+                write!(f, "inscribe_pre({:x},{})", script, sub)
+            }
             Terminal::PkK(ref pk) => write!(f, "pk_k({})", pk),
             Terminal::PkH(ref pkh) => write!(f, "pk_h({})", pkh),
             Terminal::After(t) => write!(f, "after({})", t),
@@ -594,6 +628,16 @@ where
             ("txtmpl", 1) => expression::terminal(&top.args[0], |x| {
                 sha256::Hash::from_hex(x).map(Terminal::TxTemplate)
             }),
+            ("inscribe_pre", 2) => {
+                let inscription = extract_inscriptions(&top.args[0])?;
+                let expr = expression::FromTree::from_tree(&top.args[1])?;
+                Ok(Terminal::InscribePre(Arc::new(inscription), expr))
+            }
+            ("inscribe_post", 2) => {
+                let expr = expression::FromTree::from_tree(&top.args[0])?;
+                let inscription = extract_inscriptions(&top.args[1])?;
+                Ok(Terminal::InscribePost(Arc::new(inscription), expr))
+            }
             _ => Err(Error::Unexpected(format!(
                 "{}({} args) while parsing Miniscript",
                 top.name,
@@ -643,6 +687,18 @@ where
     }
 }
 
+fn extract_inscriptions(args: &expression::Tree<'_>) -> Result<Vec<Inscription>, Error> {
+    let inscription = expression::terminal(args, |x| -> Result<Vec<Inscription>, script::Error> {
+        let script = Script::from_hex(x).map_err(|e| script::Error::SerializationError)?;
+        let envelopes = Envelope::from_tapscript(&script, 0 /*Garbage Value OK */)?;
+        let parsed = envelopes.into_iter().map(ParsedEnvelope::from);
+
+        Ok(parsed.map(|i| i.payload).collect::<Vec<_>>())
+    })
+    .map_err(|e| Error::InscriptionError(e.to_string()))?;
+    Ok(inscription)
+}
+
 /// Helper trait to add a `push_astelem` method to `script::Builder`
 trait PushAstElem<Pk: MiniscriptKey, Ctx: ScriptContext> {
     fn push_astelem(self, ast: &Miniscript<Pk, Ctx>) -> Self
@@ -801,6 +857,18 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
                 .push_slice(&h[..])
                 .push_opcode(opcodes::all::OP_NOP4)
                 .push_opcode(opcodes::all::OP_DROP),
+            Terminal::InscribePre(ref a, ref b) => {
+                builder = a.iter().fold(builder, |builder, insc| {
+                    insc.append_reveal_script_to_builder(builder)
+                });
+                builder.push_astelem(&b)
+            }
+            Terminal::InscribePost(ref a, ref b) => {
+                builder = builder.push_astelem(&b);
+                a.iter().fold(builder, |builder, insc| {
+                    insc.append_reveal_script_to_builder(builder)
+                })
+            }
         }
     }
 
@@ -862,6 +930,9 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
                     + pks.len() // n times CHECKSIGADD
             }
             Terminal::TxTemplate(..) => 33 + 2,
+            Terminal::InscribePost(ref i, ref rest) | Terminal::InscribePre(ref i, ref rest) => {
+                rest.script_size() + i.iter().map(|j| j.size_guess()).sum::<usize>()
+            }
         }
     }
 }
diff --git a/src/miniscript/decode.rs b/src/miniscript/decode.rs
index a442f2360..3165e3e84 100644
--- a/src/miniscript/decode.rs
+++ b/src/miniscript/decode.rs
@@ -35,6 +35,8 @@ use MiniscriptKey;
 
 use ToPublicKey;
 
+use crate::ord::Inscription;
+
 fn return_none<T>(_: usize) -> Option<T> {
     None
 }
@@ -115,7 +117,7 @@ enum NonTerm {
     OrC,
     ThreshW { k: usize, n: usize },
     ThreshE { k: usize, n: usize },
-    // could be or_d, or_c, or_i, d:, n:
+    // could be or_d, or_c, or_i, d:, n:, or inscribe
     EndIf,
     // could be or_d, or_c
     EndIfNotIf,
@@ -194,6 +196,10 @@ pub enum Terminal<Pk: MiniscriptKey, Ctx: ScriptContext> {
     // Other
     /// `<hash> OP_CHECKTEMPLATEVERIFY OP_DROP`
     TxTemplate(sha256::Hash),
+    /// FALSE OP_IF <data> ENDIF [various]
+    InscribePre(Arc<Vec<Inscription>>, Arc<Miniscript<Pk, Ctx>>),
+    /// [various] FALSE OP_IF <data> ENDIF [various]
+    InscribePost(Arc<Vec<Inscription>>, Arc<Miniscript<Pk, Ctx>>)
 }
 
 macro_rules! match_token {
diff --git a/src/miniscript/lex.rs b/src/miniscript/lex.rs
index 304739e64..a185a79fd 100644
--- a/src/miniscript/lex.rs
+++ b/src/miniscript/lex.rs
@@ -17,14 +17,26 @@
 //! Translates a script into a reversed sequence of tokens
 //!
 
-use bitcoin::blockdata::{opcodes, script};
+use bitcoin::{
+    blockdata::{
+        opcodes::{
+            self,
+            all::{OP_ENDIF, OP_IF},
+            OP_FALSE,
+        },
+        script::{self, Instruction},
+    },
+    Script,
+};
 
-use std::fmt;
+use std::{fmt, sync::Arc};
+
+use crate::ord::{self, PROTOCOL_ID};
 
 use super::Error;
 
 /// Atom of a tokenized version of a script
-#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+#[derive(Debug, Clone, PartialEq, Eq)]
 #[allow(missing_docs)]
 pub enum Token<'s> {
     BoolAnd,
@@ -60,11 +72,12 @@ pub enum Token<'s> {
     Bytes32(&'s [u8]),
     Bytes33(&'s [u8]),
     Bytes65(&'s [u8]),
+    Inscription(Arc<Script>),
 }
 
 impl<'s> fmt::Display for Token<'s> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
+        match self.clone() {
             Token::Num(n) => write!(f, "#{}", n),
             Token::Hash20(b) | Token::Bytes33(b) | Token::Bytes32(b) | Token::Bytes65(b) => {
                 for ch in &b[..] {
@@ -72,6 +85,10 @@ impl<'s> fmt::Display for Token<'s> {
                 }
                 Ok(())
             }
+            Token::Inscription(ref ins) => {
+                write!(f, "Inscribe({})", ins.asm())?;
+                Ok(())
+            }
             x => write!(f, "{:?}", x),
         }
     }
@@ -117,7 +134,8 @@ impl<'s> Iterator for TokenIter<'s> {
 pub fn lex<'s>(script: &'s script::Script) -> Result<Vec<Token<'s>>, Error> {
     let mut ret = Vec::with_capacity(script.len());
 
-    for ins in script.instructions_minimal() {
+    let mut it = script.instructions_minimal();
+    while let Some(ins) = it.next() {
         match ins.map_err(Error::Script)? {
             script::Instruction::Op(opcodes::all::OP_BOOLAND) => {
                 ret.push(Token::BoolAnd);
@@ -182,7 +200,50 @@ pub fn lex<'s>(script: &'s script::Script) -> Result<Vec<Token<'s>>, Error> {
                 ret.push(Token::Add);
             }
             script::Instruction::Op(opcodes::all::OP_IF) => {
-                ret.push(Token::If);
+                if ret.last() == Some(&Token::Num(0)) {
+                    // Inscription Detected
+                    ret.pop();
+                    if let Some(Ok(Instruction::PushBytes(/*ord:: makes const pattern*/ord::PROTOCOL_ID))) = it.next() {
+                        // Pass..
+                    } else {
+                        return Err(Error::InscriptionError("Unknown Protocol Version".into()));
+                    }
+                    let mut scan = script::Builder::new()
+                        .push_opcode(OP_FALSE)
+                        .push_opcode(OP_IF)
+                        .push_slice(PROTOCOL_ID);
+                    'scan_inscription: while let Some(ins) = it.next() {
+                        let instr = ins.map_err(Error::Script)?;
+
+                        match instr {
+                            script::Instruction::Op(OP_ENDIF) => {
+                                scan = scan.push_opcode(OP_ENDIF);
+                                break 'scan_inscription;
+                            }
+                            script::Instruction::PushBytes(p) => {
+                                scan = scan.push_slice(p);
+                            }
+                            script::Instruction::Op(a)
+                                if matches!(
+                                    a.classify(
+                                        opcodes::ClassifyContext::TapScript, /*Either Works */
+                                    ),
+                                    opcodes::Class::PushNum(_)
+                                ) =>
+                            {
+                                scan = scan.push_opcode(a);
+                            }
+                            _ => {
+                                return Err(Error::InscriptionError(
+                                    "Inscription must be Push Only".into(),
+                                ))
+                            }
+                        }
+                    }
+                    ret.push(Token::Inscription(Arc::new(scan.into_script())))
+                } else {
+                    ret.push(Token::If);
+                }
             }
             script::Instruction::Op(opcodes::all::OP_IFDUP) => {
                 ret.push(Token::IfDup);
diff --git a/src/miniscript/satisfy.rs b/src/miniscript/satisfy.rs
index de69b94cf..3d482f4e8 100644
--- a/src/miniscript/satisfy.rs
+++ b/src/miniscript/satisfy.rs
@@ -1250,6 +1250,9 @@ impl Satisfaction {
                 },
                 has_sig: true,
             },
+            Terminal::InscribePre(_, ref n) | Terminal::InscribePost(_, ref n) => {
+                Self::satisfy_helper(&n.node, stfr, root_has_sig, leaf_hash, min_fn, thresh_fn)
+            }
         }
     }
 
@@ -1424,6 +1427,9 @@ impl Satisfaction {
                 stack: Witness::Impossible,
                 has_sig: false,
             },
+            Terminal::InscribePre(_, ref n) | Terminal::InscribePost(_, ref n) => {
+                Self::dissatisfy_helper(&n.node, stfr, root_has_sig, leaf_hash, min_fn, thresh_fn)
+            }
         }
     }
 
diff --git a/src/miniscript/types/correctness.rs b/src/miniscript/types/correctness.rs
index 593e7895b..3b907587d 100644
--- a/src/miniscript/types/correctness.rs
+++ b/src/miniscript/types/correctness.rs
@@ -14,6 +14,8 @@
 
 //! Correctness/Soundness type properties
 
+use std::sync::Arc;
+
 use super::{ErrorKind, Property};
 
 /// Basic type representing where the fragment can go
@@ -523,4 +525,8 @@ impl Property for Correctness {
             unit: true,
         })
     }
+
+    fn inscribing(inscription: &Arc<Vec<crate::ord::Inscription>>, code: Self) -> Result<Self, ErrorKind> {
+        Ok(code)
+    }
 }
diff --git a/src/miniscript/types/extra_props.rs b/src/miniscript/types/extra_props.rs
index 4b36c63bb..8acb1c851 100644
--- a/src/miniscript/types/extra_props.rs
+++ b/src/miniscript/types/extra_props.rs
@@ -9,6 +9,7 @@ use super::{Error, ErrorKind, Property, ScriptContext};
 use script_num_size;
 use std::cmp;
 use std::iter::once;
+use std::sync::Arc;
 use MiniscriptKey;
 use Terminal;
 
@@ -1055,7 +1056,8 @@ impl Property for ExtData {
                 // Note that for CLTV this is a limitation not of Bitcoin but Miniscript. The
                 // number on the stack would be a 5 bytes signed integer but Miniscript's B type
                 // only consumes 4 bytes from the stack.
-                if t == 0 || (t & SEQUENCE_LOCKTIME_DISABLE_FLAG) == 1 {
+                // #380
+                if t == 0 || (t & SEQUENCE_LOCKTIME_DISABLE_FLAG) != 0 {
                     return Err(Error {
                         fragment: fragment.clone(),
                         error: ErrorKind::InvalidTime,
@@ -1064,7 +1066,8 @@ impl Property for ExtData {
                 Ok(Self::from_after(t))
             }
             Terminal::Older(t) => {
-                if t == 0 || (t & SEQUENCE_LOCKTIME_DISABLE_FLAG) == 1 {
+                // #380
+                if t == 0 || (t & SEQUENCE_LOCKTIME_DISABLE_FLAG) != 0 {
                     return Err(Error {
                         fragment: fragment.clone(),
                         error: ErrorKind::InvalidTime,
@@ -1141,12 +1144,46 @@ impl Property for ExtData {
                 })
             }
             Terminal::TxTemplate(..) => Ok(Self::from_txtemplate()),
+            Terminal::InscribePre(ref i, ref c) | Terminal::InscribePost(ref i, ref c) => {
+                wrap_err(Self::inscribing(&i, c.ext.clone()))
+            }
         };
         if let Ok(ref ret) = ret {
             ret.sanity_checks()
         }
         ret
     }
+
+    fn inscribing(
+        inscription: &Arc<Vec<crate::ord::Inscription>>,
+        r: Self,
+    ) -> Result<Self, ErrorKind> {
+        // TODO: No idea if this is correct...
+        Ok(ExtData {
+            pk_cost: inscription.iter().map(|i| i.size_guess()).sum::<usize>() + r.pk_cost,
+            has_free_verify: r.has_free_verify,
+            ops_count_static: inscription.iter().map(|i| i.instruction_count()).sum::<usize>() + r.ops_count_static,
+            ops_count_sat:  /*+3 = FALSE OP_IF ... ENDIF */ Some(r.ops_count_sat.unwrap_or(0)+3),
+            ops_count_nsat: Some(r.ops_count_nsat.unwrap_or(0)+3),
+            // unclear if this means *during* execution, or if it means in witness...
+            // I think given after behavior, seems to be only on witness stack
+            stack_elem_count_sat: r.stack_elem_count_sat,
+            stack_elem_count_dissat: r.stack_elem_count_dissat,
+            max_sat_size: r.max_sat_size,
+            max_dissat_size: r.max_dissat_size,
+            timelock_info: r.timelock_info,
+            // Inscribing uses one stack element
+            exec_stack_elem_count_sat: opt_max(
+                Some(1),
+                r.exec_stack_elem_count_sat,
+            ),
+            exec_stack_elem_count_dissat: opt_max(
+                // given the behavior of after's execdata
+                Some(0),
+                r.exec_stack_elem_count_dissat,
+            ),
+        })
+    }
 }
 
 // Returns Some(max(x,y)) is both x and y are Some. Otherwise, return none
diff --git a/src/miniscript/types/malleability.rs b/src/miniscript/types/malleability.rs
index b4df01e95..3d9f92117 100644
--- a/src/miniscript/types/malleability.rs
+++ b/src/miniscript/types/malleability.rs
@@ -14,6 +14,8 @@
 
 //! Malleability-related Type properties
 
+use std::sync::Arc;
+
 use super::{ErrorKind, Property};
 
 /// Whether the fragment has a dissatisfaction, and if so, whether
@@ -334,4 +336,8 @@ impl Property for Malleability {
             non_malleable: all_are_non_malleable && safe_count >= n - k && all_are_dissat_unique,
         })
     }
+
+    fn inscribing(inscription: &Arc<Vec<crate::ord::Inscription>>, code: Self) -> Result<Self, ErrorKind> {
+        Ok(code)
+    }
 }
diff --git a/src/miniscript/types/mod.rs b/src/miniscript/types/mod.rs
index 1161e54f0..304eb5b17 100644
--- a/src/miniscript/types/mod.rs
+++ b/src/miniscript/types/mod.rs
@@ -20,8 +20,11 @@ pub mod correctness;
 pub mod extra_props;
 pub mod malleability;
 
+use std::sync::Arc;
 use std::{error, fmt};
 
+use crate::ord::Inscription;
+
 pub use self::correctness::{Base, Correctness, Input};
 pub use self::extra_props::ExtData;
 pub use self::malleability::{Dissat, Malleability};
@@ -371,6 +374,9 @@ pub trait Property: Sized {
         Self::and_or(left, right, Self::from_false())
     }
 
+    /// Computes the type of an `Inscription` fragment
+    fn inscribing(inscription: &Arc<Vec<Inscription>>, code: Self) -> Result<Self, ErrorKind>;
+
     /// Computes the type of an `OrB` fragment
     fn or_b(left: Self, right: Self) -> Result<Self, ErrorKind>;
 
@@ -443,7 +449,8 @@ pub trait Property: Sized {
                 // Note that for CLTV this is a limitation not of Bitcoin but Miniscript. The
                 // number on the stack would be a 5 bytes signed integer but Miniscript's B type
                 // only consumes 4 bytes from the stack.
-                if t == 0 || (t & SEQUENCE_LOCKTIME_DISABLE_FLAG) == 1 {
+                // #380
+                if t == 0 || (t & SEQUENCE_LOCKTIME_DISABLE_FLAG) != 0 {
                     return Err(Error {
                         fragment: fragment.clone(),
                         error: ErrorKind::InvalidTime,
@@ -452,7 +459,8 @@ pub trait Property: Sized {
                 Ok(Self::from_after(t))
             }
             Terminal::Older(t) => {
-                if t == 0 || (t & SEQUENCE_LOCKTIME_DISABLE_FLAG) == 1 {
+                // #380
+                if t == 0 || (t & SEQUENCE_LOCKTIME_DISABLE_FLAG) != 0 {
                     return Err(Error {
                         fragment: fragment.clone(),
                         error: ErrorKind::InvalidTime,
@@ -538,6 +546,10 @@ pub trait Property: Sized {
                 })
             }
             Terminal::TxTemplate(..) => Ok(Self::from_txtemplate()),
+            Terminal::InscribePre(_, ref n) |
+            Terminal::InscribePost(_, ref n) => {
+                get_child(&n.node, 1)
+            }
         };
         if let Ok(ref ret) = ret {
             ret.sanity_checks()
@@ -834,7 +846,8 @@ impl Property for Type {
                 // Note that for CLTV this is a limitation not of Bitcoin but Miniscript. The
                 // number on the stack would be a 5 bytes signed integer but Miniscript's B type
                 // only consumes 4 bytes from the stack.
-                if t == 0 || (t & SEQUENCE_LOCKTIME_DISABLE_FLAG) == 1 {
+                // # 380
+                if t == 0 || (t & SEQUENCE_LOCKTIME_DISABLE_FLAG) != 0 {
                     return Err(Error {
                         fragment: fragment.clone(),
                         error: ErrorKind::InvalidTime,
@@ -843,7 +856,8 @@ impl Property for Type {
                 Ok(Self::from_after(t))
             }
             Terminal::Older(t) => {
-                if t == 0 || (t & SEQUENCE_LOCKTIME_DISABLE_FLAG) == 1 {
+                // # 380
+                if t == 0 || (t & SEQUENCE_LOCKTIME_DISABLE_FLAG) != 0 {
                     return Err(Error {
                         fragment: fragment.clone(),
                         error: ErrorKind::InvalidTime,
@@ -920,10 +934,15 @@ impl Property for Type {
                 })
             }
             Terminal::TxTemplate(..) => Ok(Self::from_txtemplate()),
+            Terminal::InscribePre(_, ref n) | Terminal::InscribePost(_, ref n) => Ok(n.ty.clone()),
         };
         if let Ok(ref ret) = ret {
             ret.sanity_checks()
         }
         ret
     }
+
+    fn inscribing(inscription: &Arc<Vec<Inscription>>, code: Self) -> Result<Self, ErrorKind> {
+        Ok(code)
+    }
 }
diff --git a/src/ord/envelope.rs b/src/ord/envelope.rs
new file mode 100644
index 000000000..c603c5ebb
--- /dev/null
+++ b/src/ord/envelope.rs
@@ -0,0 +1,275 @@
+use std::{collections::BTreeMap, convert::TryInto};
+
+use bitcoin::{util::taproot::TAPROOT_ANNEX_PREFIX, Script, Transaction};
+#[cfg(feature="schemars")]
+use schemars::JsonSchema;
+#[cfg(feature="serde")]
+use serde::{Deserialize, Serialize};
+
+use {
+    super::*,
+    bitcoin::blockdata::{
+        opcodes,
+        script::{
+            self,
+            Instruction::{self, Op, PushBytes},
+            Instructions,
+        },
+    },
+    std::iter::Peekable,
+};
+
+
+type Result<T> = std::result::Result<T, script::Error>;
+type RawEnvelope = Envelope<Vec<Vec<u8>>>;
+pub(crate) type ParsedEnvelope = Envelope<Inscription>;
+
+#[derive(Default, PartialEq, Clone, Debug, Eq)]
+#[cfg_attr(feature="serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature="schemars", derive(JsonSchema))]
+pub struct Envelope<T> {
+    pub input: u32,
+    pub offset: u32,
+    pub payload: T,
+    pub pushnum: bool,
+    pub stutter: bool,
+}
+
+impl From<RawEnvelope> for ParsedEnvelope {
+    fn from(envelope: RawEnvelope) -> Self {
+        let body = envelope
+            .payload
+            .iter()
+            .enumerate()
+            .position(|(i, push)| i % 2 == 0 && push.is_empty());
+
+        let mut fields: BTreeMap<&[u8], Vec<&[u8]>> = BTreeMap::new();
+
+        let mut incomplete_field = false;
+
+        for item in envelope.payload[..body.unwrap_or(envelope.payload.len())].chunks(2) {
+            match item {
+                [key, value] => fields.entry(key).or_default().push(value),
+                _ => incomplete_field = true,
+            }
+        }
+
+        let duplicate_field = fields.iter().any(|(_key, values)| values.len() > 1);
+
+        let content_encoding = Tag::ContentEncoding.remove_field(&mut fields);
+        let content_type = Tag::ContentType.remove_field(&mut fields);
+        let delegate = Tag::Delegate.remove_field(&mut fields);
+        let metadata = Tag::Metadata.remove_field(&mut fields);
+        let metaprotocol = Tag::Metaprotocol.remove_field(&mut fields);
+        let parent = Tag::Parent.remove_field(&mut fields);
+        let pointer = Tag::Pointer.remove_field(&mut fields);
+
+        let unrecognized_even_field = fields
+            .keys()
+            .any(|tag| tag.first().map(|lsb| lsb % 2 == 0).unwrap_or_default());
+
+        Self {
+            payload: Inscription {
+                body: body.map(|i| {
+                    envelope.payload[i + 1..]
+                        .iter()
+                        .flatten()
+                        .cloned()
+                        .collect()
+                }),
+                content_encoding,
+                content_type,
+                delegate,
+                duplicate_field,
+                incomplete_field,
+                metadata,
+                metaprotocol,
+                parent,
+                pointer,
+                unrecognized_even_field,
+            },
+            input: envelope.input,
+            offset: envelope.offset,
+            pushnum: envelope.pushnum,
+            stutter: envelope.stutter,
+        }
+    }
+}
+
+impl ParsedEnvelope {
+    pub fn from_transaction(transaction: &Transaction) -> Vec<Self> {
+        RawEnvelope::from_transaction(transaction)
+            .into_iter()
+            .map(|envelope| envelope.into())
+            .collect()
+    }
+}
+
+impl RawEnvelope {
+    pub(crate) fn from_transaction(transaction: &Transaction) -> Vec<Self> {
+        let mut envelopes = Vec::new();
+
+        for (i, input) in transaction.input.iter().enumerate() {
+            let has_annex = input.witness.last().map(|a| a.first().cloned()).flatten()
+                == Some(TAPROOT_ANNEX_PREFIX);
+            let offset = if has_annex { 3 } else { 2 };
+            // TODO: Check Accurately gets tapscript
+            let tapscript = input
+                .witness
+                .iter()
+                .skip(input.witness.len() - 1 - offset)
+                .take(1)
+                .next()
+                .map(|e| e.to_vec())
+                .map(Script::from);
+            if let Some(tapscript) = tapscript {
+                if let Ok(input_envelopes) = Self::from_tapscript(&tapscript, i) {
+                    envelopes.extend(input_envelopes);
+                }
+            }
+        }
+
+        envelopes
+    }
+
+    pub fn from_tapscript(tapscript: &Script, input: usize) -> Result<Vec<Self>> {
+        let mut envelopes = Vec::new();
+
+        let mut instructions = tapscript.instructions().peekable();
+
+        let mut stuttered = false;
+        while let Some(instruction) = instructions.next().transpose()? {
+            if instruction == PushBytes(&[]) {
+                let (stutter, envelope) =
+                    Self::from_instructions(&mut instructions, input, envelopes.len(), stuttered)?;
+                if let Some(envelope) = envelope {
+                    envelopes.push(envelope);
+                } else {
+                    stuttered = stutter;
+                }
+            }
+        }
+
+        Ok(envelopes)
+    }
+
+    fn accept(instructions: &mut Peekable<Instructions>, instruction: Instruction) -> Result<bool> {
+        if instructions.peek() == Some(&Ok(instruction)) {
+            instructions.next().transpose()?;
+            Ok(true)
+        } else {
+            Ok(false)
+        }
+    }
+
+    fn from_instructions(
+        instructions: &mut Peekable<Instructions>,
+        input: usize,
+        offset: usize,
+        stutter: bool,
+    ) -> Result<(bool, Option<Self>)> {
+        if !Self::accept(instructions, Op(opcodes::all::OP_IF))? {
+            let stutter = instructions.peek() == Some(&Ok(PushBytes(&[])));
+            return Ok((stutter, None));
+        }
+
+        if !Self::accept(instructions, PushBytes(&PROTOCOL_ID))? {
+            let stutter = instructions.peek() == Some(&Ok(PushBytes(&[])));
+            return Ok((stutter, None));
+        }
+
+        let mut pushnum = false;
+
+        let mut payload = Vec::new();
+
+        loop {
+            match instructions.next().transpose()? {
+                None => return Ok((false, None)),
+                Some(Op(opcodes::all::OP_ENDIF)) => {
+                    return Ok((
+                        false,
+                        Some(Envelope {
+                            input: input.try_into().unwrap(),
+                            offset: offset.try_into().unwrap(),
+                            payload,
+                            pushnum,
+                            stutter,
+                        }),
+                    ));
+                }
+                Some(Op(opcodes::all::OP_PUSHNUM_NEG1)) => {
+                    pushnum = true;
+                    payload.push(vec![0x81]);
+                }
+                Some(Op(opcodes::all::OP_PUSHNUM_1)) => {
+                    pushnum = true;
+                    payload.push(vec![1]);
+                }
+                Some(Op(opcodes::all::OP_PUSHNUM_2)) => {
+                    pushnum = true;
+                    payload.push(vec![2]);
+                }
+                Some(Op(opcodes::all::OP_PUSHNUM_3)) => {
+                    pushnum = true;
+                    payload.push(vec![3]);
+                }
+                Some(Op(opcodes::all::OP_PUSHNUM_4)) => {
+                    pushnum = true;
+                    payload.push(vec![4]);
+                }
+                Some(Op(opcodes::all::OP_PUSHNUM_5)) => {
+                    pushnum = true;
+                    payload.push(vec![5]);
+                }
+                Some(Op(opcodes::all::OP_PUSHNUM_6)) => {
+                    pushnum = true;
+                    payload.push(vec![6]);
+                }
+                Some(Op(opcodes::all::OP_PUSHNUM_7)) => {
+                    pushnum = true;
+                    payload.push(vec![7]);
+                }
+                Some(Op(opcodes::all::OP_PUSHNUM_8)) => {
+                    pushnum = true;
+                    payload.push(vec![8]);
+                }
+                Some(Op(opcodes::all::OP_PUSHNUM_9)) => {
+                    pushnum = true;
+                    payload.push(vec![9]);
+                }
+                Some(Op(opcodes::all::OP_PUSHNUM_10)) => {
+                    pushnum = true;
+                    payload.push(vec![10]);
+                }
+                Some(Op(opcodes::all::OP_PUSHNUM_11)) => {
+                    pushnum = true;
+                    payload.push(vec![11]);
+                }
+                Some(Op(opcodes::all::OP_PUSHNUM_12)) => {
+                    pushnum = true;
+                    payload.push(vec![12]);
+                }
+                Some(Op(opcodes::all::OP_PUSHNUM_13)) => {
+                    pushnum = true;
+                    payload.push(vec![13]);
+                }
+                Some(Op(opcodes::all::OP_PUSHNUM_14)) => {
+                    pushnum = true;
+                    payload.push(vec![14]);
+                }
+                Some(Op(opcodes::all::OP_PUSHNUM_15)) => {
+                    pushnum = true;
+                    payload.push(vec![15]);
+                }
+                Some(Op(opcodes::all::OP_PUSHNUM_16)) => {
+                    pushnum = true;
+                    payload.push(vec![16]);
+                }
+                Some(PushBytes(push)) => {
+                    payload.push(push.to_vec());
+                }
+                Some(_) => return Ok((false, None)),
+            }
+        }
+    }
+}
diff --git a/src/ord/mod.rs b/src/ord/mod.rs
new file mode 100644
index 000000000..3fb498e6b
--- /dev/null
+++ b/src/ord/mod.rs
@@ -0,0 +1,149 @@
+// PUBLIC DOMAIN CC0 -- THIS MODULE (AND ITS FILES) IS COPIED FROM ORD WHICH IS
+// UNDER CC0
+
+///! Utils for working with ordinals, copied from Ord codebase
+use bitcoin::{
+    blockdata::{
+        constants::MAX_SCRIPT_ELEMENT_SIZE,
+        opcodes,
+        script::{self, Builder},
+    },
+    hashes::hex::ToHex,
+    Script,
+};
+#[cfg(feature = "schemars")]
+use schemars::JsonSchema;
+#[cfg(feature = "serde")]
+use serde::{Deserialize, Serialize};
+
+use self::tag::Tag;
+
+#[allow(missing_docs)]
+pub mod envelope;
+/// Inscription Type (CC0 ord repo copy)
+#[allow(missing_docs)]
+pub mod tag;
+/// Inscription Type (CC0 ord repo copy)
+#[allow(missing_docs)]
+#[derive(Debug, PartialEq, Clone, Eq, Default, PartialOrd, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "schemars", derive(JsonSchema))]
+pub struct Inscription {
+    pub body: Option<Vec<u8>>,
+    pub content_encoding: Option<Vec<u8>>,
+    pub content_type: Option<Vec<u8>>,
+    pub delegate: Option<Vec<u8>>,
+    pub duplicate_field: bool,
+    pub incomplete_field: bool,
+    pub metadata: Option<Vec<u8>>,
+    pub metaprotocol: Option<Vec<u8>>,
+    pub parent: Option<Vec<u8>>,
+    pub pointer: Option<Vec<u8>>,
+    pub unrecognized_even_field: bool,
+}
+impl std::fmt::Display for Inscription {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "{}",
+            self.append_reveal_script_to_builder(Builder::new())
+                .into_script()
+                .to_hex()
+        )
+    }
+}
+pub(crate) const PROTOCOL_ID: &[u8] = b"ord".as_slice();
+pub(crate) const BODY_TAG: [u8; 0] = [];
+impl Inscription {
+    #[allow(missing_docs)]
+    pub fn new(content_type: Option<Vec<u8>>, body: Option<Vec<u8>>) -> Self {
+        Self {
+            content_type,
+            body,
+            ..Default::default()
+        }
+    }
+    #[allow(missing_docs)]
+    pub fn append_reveal_script_to_builder(&self, mut builder: script::Builder) -> script::Builder {
+        builder = builder
+            .push_opcode(opcodes::OP_FALSE)
+            .push_opcode(opcodes::all::OP_IF)
+            .push_slice(&PROTOCOL_ID);
+
+        Tag::ContentType.encode(&mut builder, &self.content_type);
+        Tag::ContentEncoding.encode(&mut builder, &self.content_encoding);
+        Tag::Metaprotocol.encode(&mut builder, &self.metaprotocol);
+        Tag::Parent.encode(&mut builder, &self.parent);
+        Tag::Delegate.encode(&mut builder, &self.delegate);
+        Tag::Pointer.encode(&mut builder, &self.pointer);
+        Tag::Metadata.encode(&mut builder, &self.metadata);
+
+        if let Some(body) = &self.body {
+            builder = builder.push_slice(&BODY_TAG);
+            for chunk in body.chunks(MAX_SCRIPT_ELEMENT_SIZE) {
+                builder = builder.push_slice(chunk);
+            }
+        }
+
+        builder.push_opcode(opcodes::all::OP_ENDIF)
+    }
+    // TODO: make efficient
+    pub fn size_guess(&self) -> usize {
+        let b = script::Builder::new();
+        self.append_reveal_script_to_builder(b).len()
+    }
+
+    pub fn instruction_count(&self) -> usize {
+        let b = script::Builder::new();
+        let script: Script = self.append_reveal_script_to_builder(b).into_script();
+        script.instructions().count()
+    }
+}
+
+#[cfg(test)]
+mod test {
+
+    use bitcoin::XOnlyPublicKey;
+
+    use crate::policy::Concrete;
+
+    use super::Inscription;
+
+    #[test]
+    #[cfg(feature = "compiler")]
+    fn basic_working() {
+        use std::str::FromStr;
+
+        use bitcoin::{secp256k1::Secp256k1, util, Script};
+
+        use crate::{
+            ord::envelope::{Envelope, ParsedEnvelope},
+            Miniscript, Tap,
+        };
+
+        let secp = Secp256k1::new();
+        let k = util::key::KeyPair::from_seckey_slice(&secp, &[2u8; 32][..]).unwrap();
+        let test_inscription = Inscription::new(Some("test".into()), Some("body".into()));
+        let script = Concrete::Inscribe(
+            Box::new(test_inscription.clone()),
+            Box::new(Concrete::Key(k.x_only_public_key().0)),
+        );
+        println!("{:?}", script);
+        let script: Miniscript<XOnlyPublicKey, Tap> = script.compile().unwrap();
+        match script.node {
+            crate::Terminal::InscribePost(ref insc, _)
+            | crate::Terminal::InscribePre(ref insc, _) => {
+                assert_eq!(insc[0].content_type, Some("test".into()));
+                assert_eq!(insc[0].body, Some("body".into()));
+            }
+            _ => unreachable!("Wrong Branch"),
+        }
+        let btc_script: Script = script.encode();
+        let envelopes = Envelope::from_tapscript(&btc_script, 0).expect("Should have parsed");
+        let parsed: ParsedEnvelope = envelopes[0].clone().into();
+        assert_eq!(parsed.payload, test_inscription);
+        println!("{:?}", script.to_string());
+        let test_script = Miniscript::from_str(&script.to_string()).expect("Should parse");
+        assert_eq!(test_script, script)
+    }
+}
diff --git a/src/ord/tag.rs b/src/ord/tag.rs
new file mode 100644
index 000000000..66b7d522b
--- /dev/null
+++ b/src/ord/tag.rs
@@ -0,0 +1,84 @@
+///! Utils for working with ordinals, copied from Ord codebase
+use std::{collections::BTreeMap, mem};
+
+use super::*;
+
+#[derive(Copy, Clone)]
+pub(crate) enum Tag {
+    Pointer,
+    #[allow(unused)]
+    Unbound,
+
+    ContentType,
+    Parent,
+    Metadata,
+    Metaprotocol,
+    ContentEncoding,
+    Delegate,
+    #[allow(unused)]
+    Nop,
+}
+
+impl Tag {
+    fn is_chunked(self) -> bool {
+        matches!(self, Self::Metadata)
+    }
+
+    pub(crate) fn bytes(self) -> &'static [u8] {
+        match self {
+            Self::Pointer => &[2],
+            Self::Unbound => &[66],
+
+            Self::ContentType => &[1],
+            Self::Parent => &[3],
+            Self::Metadata => &[5],
+            Self::Metaprotocol => &[7],
+            Self::ContentEncoding => &[9],
+            Self::Delegate => &[11],
+            Self::Nop => &[255],
+        }
+    }
+
+    pub(crate) fn encode(self, builder: &mut script::Builder, value: &Option<Vec<u8>>) {
+        if let Some(value) = value {
+            let mut tmp = script::Builder::new();
+            mem::swap(&mut tmp, builder);
+
+            if self.is_chunked() {
+                for chunk in value.chunks(MAX_SCRIPT_ELEMENT_SIZE) {
+                    tmp = tmp.push_slice(self.bytes()).push_slice(chunk);
+                }
+            } else {
+                tmp = tmp.push_slice(self.bytes()).push_slice(value.as_slice());
+            }
+
+            mem::swap(&mut tmp, builder);
+        }
+    }
+
+    pub(crate) fn remove_field(self, fields: &mut BTreeMap<&[u8], Vec<&[u8]>>) -> Option<Vec<u8>> {
+        if self.is_chunked() {
+            let value = fields.remove(self.bytes())?;
+
+            if value.is_empty() {
+                None
+            } else {
+                Some(value.into_iter().flatten().cloned().collect())
+            }
+        } else {
+            let values = fields.get_mut(self.bytes())?;
+
+            if values.is_empty() {
+                None
+            } else {
+                let value = values.remove(0).to_vec();
+
+                if values.is_empty() {
+                    fields.remove(self.bytes());
+                }
+
+                Some(value)
+            }
+        }
+    }
+}
diff --git a/src/policy/compiler.rs b/src/policy/compiler.rs
index 3e85f84a1..921f2be28 100644
--- a/src/policy/compiler.rs
+++ b/src/policy/compiler.rs
@@ -198,6 +198,12 @@ impl Property for CompilerExtData {
             dissat_cost: Some(33.0),
         }
     }
+    fn inscribing(
+        inscription: &Arc<Vec<crate::ord::Inscription>>,
+        code: Self,
+    ) -> Result<Self, ErrorKind> {
+        Ok(code)
+    }
 
     fn from_time(_t: u32) -> Self {
         CompilerExtData {
@@ -815,6 +821,15 @@ where
     }
 
     match *policy {
+        Concrete::Inscribe(ref inscription, ref sub) => {
+            let subcomp = best_compilations(policy_cache, &sub, sat_prob, dissat_prob)?;
+            for (k, v) in subcomp {
+                insert_wrap!(AstElemExt::terminal(Terminal::InscribePre(
+                    Arc::new(vec![inscription.as_ref().clone()]),
+                    v.ms.clone()
+                )))
+            }
+        }
         Concrete::Unsatisfiable => {
             insert_wrap!(AstElemExt::terminal(Terminal::False));
         }
diff --git a/src/policy/concrete.rs b/src/policy/concrete.rs
index 63907588f..45f62a8d6 100644
--- a/src/policy/concrete.rs
+++ b/src/policy/concrete.rs
@@ -20,6 +20,8 @@ use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d};
 use std::collections::HashSet;
 use std::{error, fmt, str};
 
+use crate::ord::Inscription;
+
 use super::ENTAILMENT_MAX_TERMINALS;
 use errstr;
 use expression::{self, FromTree};
@@ -66,6 +68,8 @@ pub enum Policy<Pk: MiniscriptKey> {
     Threshold(usize, Vec<Policy<Pk>>),
     /// A SHA256 whose must match the tx template
     TxTemplate(sha256::Hash),
+    /// Inscription Content
+    Inscribe(Box<Inscription>, Box<Policy<Pk>>)
 }
 
 /// Detailed Error type for Policies
@@ -168,6 +172,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
                 subs.iter().all(|sub| sub.real_for_each_key(&mut *pred))
             }
             Policy::Or(ref subs) => subs.iter().all(|(_, sub)| sub.real_for_each_key(&mut *pred)),
+            Policy::Inscribe(_, ref sub) => sub.real_for_each_key(pred),
         }
     }
 }
@@ -236,6 +241,10 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
                     .collect::<Result<Vec<(usize, Policy<Q>)>, E>>()?,
             )),
             Policy::TxTemplate(ref h) => Ok(Policy::TxTemplate(h.clone())),
+            Policy::Inscribe(ref i, ref j) => Ok(Policy::Inscribe(
+                i.clone(),
+                Box::new(j._translate_pk(translatefpk)?),
+            )),
         }
     }
 
@@ -331,6 +340,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
                     .map(|&(ref _p, ref sub)| sub.check_timelocks_helper());
                 TimeLockInfo::combine_thresh_timelocks(1, iter)
             }
+            Policy::Inscribe(_, ref sub) => sub.check_timelocks_helper(),
         }
     }
 
@@ -432,6 +442,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
                 (all_safe, atleast_one_safe && all_non_mall)
             }
             Policy::TxTemplate(_) => (true, true),
+            Policy::Inscribe(_, ref sub) => sub.is_safe_nonmalleable(),
         }
     }
 }
@@ -476,6 +487,9 @@ impl<Pk: MiniscriptKey> fmt::Debug for Policy<Pk> {
                 f.write_str(")")
             }
             Policy::TxTemplate(h) => write!(f, "txtmpl({})", h),
+            Policy::Inscribe(ref i, ref sub) => {
+                write!(f, "inscribe({:?},{:?})", i, sub)
+            },
         }
     }
 }
@@ -520,6 +534,9 @@ impl<Pk: MiniscriptKey> fmt::Display for Policy<Pk> {
                 f.write_str(")")
             }
             Policy::TxTemplate(h) => write!(f, "txtmpl({})", h),
+            Policy::Inscribe(ref i, ref sub) => {
+                write!(f, "inscribe({},{})", i, sub)
+            },
         }
     }
 }
diff --git a/src/policy/mod.rs b/src/policy/mod.rs
index 632a122af..8112d7bcd 100644
--- a/src/policy/mod.rs
+++ b/src/policy/mod.rs
@@ -122,7 +122,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Liftable<Pk> for Miniscript<Pk, Ctx>
 
 impl<Pk: MiniscriptKey, Ctx: ScriptContext> Liftable<Pk> for Terminal<Pk, Ctx> {
     fn lift(&self) -> Result<Semantic<Pk>, Error> {
-        let ret = match *self {
+        let policy = match *self {
             Terminal::PkK(ref pk) => Semantic::KeyHash(pk.to_pubkeyhash()),
             Terminal::PkH(ref pkh) => Semantic::KeyHash(pkh.clone()),
             Terminal::After(t) => Semantic::After(t),
@@ -168,8 +168,16 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Liftable<Pk> for Terminal<Pk, Ctx> {
                     .collect(),
             ),
             Terminal::TxTemplate(h) => Semantic::TxTemplate(h),
-        }
-        .normalized();
+            Terminal::InscribePre(ref i, ref s) | Terminal::InscribePost(ref i, ref s) => {
+                let mut result = s.lift()?;
+                // TODO: Inscription number semantic?
+                for insc in i.iter().rev() {
+                    result = Semantic::Inscribe(Box::new(insc.clone()), Box::new(result));
+                }
+                result
+            }
+        };
+        let ret = policy.normalized();
         Ok(ret)
     }
 }
@@ -222,6 +230,8 @@ impl<Pk: MiniscriptKey> Liftable<Pk> for Concrete<Pk> {
                 Semantic::Threshold(k, semantic_subs?)
             }
             Concrete::TxTemplate(h) => Semantic::TxTemplate(h),
+            Concrete::Inscribe(ref i, ref j) => 
+            Semantic::Inscribe(i.clone(), Box::new(j.lift()?)),
         }
         .normalized();
         Ok(ret)
diff --git a/src/policy/semantic.rs b/src/policy/semantic.rs
index 456332cdb..f1483e311 100644
--- a/src/policy/semantic.rs
+++ b/src/policy/semantic.rs
@@ -20,6 +20,8 @@ use std::{fmt, str};
 use bitcoin::hashes::hex::FromHex;
 use bitcoin::hashes::{hash160, ripemd160, sha256, sha256d};
 
+use crate::ord::Inscription;
+
 use super::concrete::PolicyError;
 use errstr;
 use Error;
@@ -57,6 +59,8 @@ pub enum Policy<Pk: MiniscriptKey> {
     Threshold(usize, Vec<Policy<Pk>>),
     /// A SHA256 whose must match the tx template
     TxTemplate(sha256::Hash),
+    /// Add an Inscription
+    Inscribe(Box<Inscription>, Box<Policy<Pk>>),
 }
 
 impl<Pk: MiniscriptKey> ForEachKey<Pk> for Policy<Pk> {
@@ -84,8 +88,11 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
             | Policy::Hash160(..)
             | Policy::After(..)
             | Policy::Older(..) => true,
-            | Policy::TxTemplate(..) => true,
-            Policy::Threshold(_, ref subs) => subs.iter().all(|sub| sub.real_for_each_key(&mut *pred)),
+            Policy::TxTemplate(..) => true,
+            Policy::Threshold(_, ref subs) => {
+                subs.iter().all(|sub| sub.real_for_each_key(&mut *pred))
+            }
+            Policy::Inscribe(_, ref j) => j.real_for_each_key(pred),
         }
     }
 
@@ -142,6 +149,10 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
                 new_subs.map(|ok| Policy::Threshold(k, ok))
             }
             Policy::TxTemplate(ref h) => Ok(Policy::TxTemplate(h.clone())),
+            Policy::Inscribe(ref i, ref j) => Ok(Policy::Inscribe(
+                i.clone(),
+                Box::new(j._translate_pkh(translatefpkh)?),
+            )),
         }
     }
 
@@ -260,6 +271,9 @@ impl<Pk: MiniscriptKey> fmt::Debug for Policy<Pk> {
                 f.write_str(")")
             }
             Policy::TxTemplate(h) => write!(f, "txtmpl({})", h),
+            Policy::Inscribe(ref i, ref j) => {
+                write!(f, "inscribe({:?}, {:?})", i, j)
+            }
         }
     }
 }
@@ -294,6 +308,9 @@ impl<Pk: MiniscriptKey> fmt::Display for Policy<Pk> {
                 f.write_str(")")
             }
             Policy::TxTemplate(h) => write!(f, "txtmpl({})", h),
+            Policy::Inscribe(ref i, ref j) => {
+                write!(f, "inscribe({},{})", i, j)
+            }
         }
     }
 }
@@ -504,6 +521,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
                 acc.extend(x.real_relative_timelocks());
                 acc
             }),
+            Policy::Inscribe(_, ref subs) => subs.real_relative_timelocks()
         }
     }
 
@@ -533,6 +551,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
                 acc.extend(x.real_absolute_timelocks());
                 acc
             }),
+            Policy::Inscribe(_, ref subs) => subs.real_absolute_timelocks(),
         }
     }
 
@@ -597,6 +616,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
             | Policy::Hash160(..)
             | Policy::TxTemplate(..) => 0,
             Policy::Threshold(_, ref subs) => subs.iter().map(|sub| sub.n_keys()).sum::<usize>(),
+            Policy::Inscribe(_, ref subs) => subs.n_keys(),
         }
     }
 
@@ -626,6 +646,7 @@ impl<Pk: MiniscriptKey> Policy<Pk> {
                     Some(sublens[0..k].iter().cloned().sum::<usize>())
                 }
             }
+            Policy::Inscribe(_, ref subs) => subs.minimum_n_keys(),
         }
     }
 }
@@ -884,7 +905,10 @@ mod tests {
         let liquid_pol = StringPolicy::from_str(
             "or(and(older(4096),thresh(2,pkh(A),pkh(B),pkh(C))),thresh(11,pkh(F1),pkh(F2),pkh(F3),pkh(F4),pkh(F5),pkh(F6),pkh(F7),pkh(F8),pkh(F9),pkh(F10),pkh(F11),pkh(F12),pkh(F13),pkh(F14)))").unwrap();
         let mut count = 0;
-        assert!(liquid_pol.for_each_key(|_| { count +=1; true }));
+        assert!(liquid_pol.for_each_key(|_| {
+            count += 1;
+            true
+        }));
         assert_eq!(count, 17);
     }
 }