feat: add support for OP_DROP opcode

OttoAllmendinger · OttoAllmendinger · commit e450ce1763db · 2024-10-25T13:38:18.000+02:00
Implemented with the fragment `r:`.
diff --git a/src/interpreter/mod.rs b/src/interpreter/mod.rs
@@ -682,13 +682,13 @@ where
                 Terminal::DupIf(ref _sub) if node_state.n_evaluated == 1 => {
                     self.stack.push(stack::Element::Satisfied);
                 }
-                Terminal::ZeroNotEqual(ref sub) | Terminal::Verify(ref sub)
+                Terminal::ZeroNotEqual(ref sub) | Terminal::Verify(ref sub) | Terminal::Drop(ref sub)
                     if node_state.n_evaluated == 0 =>
                 {
                     self.push_evaluation_state(node_state.node, 1, 0);
                     self.push_evaluation_state(sub, 0, 0);
                 }
-                Terminal::Verify(ref _sub) if node_state.n_evaluated == 1 => {
+                Terminal::Verify(ref _sub) | Terminal::Drop(ref _sub) if node_state.n_evaluated == 1 => {
                     match self.stack.pop() {
                         Some(stack::Element::Satisfied) => (),
                         Some(_) => return Some(Err(Error::VerifyFailed)),
diff --git a/src/iter/mod.rs b/src/iter/mod.rs
@@ -33,6 +33,7 @@ impl<'a, Pk: MiniscriptKey, Ctx: ScriptContext> TreeLike for &'a Miniscript<Pk,
             | Check(ref sub)
             | DupIf(ref sub)
             | Verify(ref sub)
+            | Drop(ref sub)
             | NonZero(ref sub)
             | ZeroNotEqual(ref sub) => Tree::Unary(sub),
             AndV(ref left, ref right)
@@ -63,6 +64,7 @@ impl<'a, Pk: MiniscriptKey, Ctx: ScriptContext> TreeLike for &'a Arc<Miniscript<
             | Check(ref sub)
             | DupIf(ref sub)
             | Verify(ref sub)
+            | Drop(ref sub)
             | NonZero(ref sub)
             | ZeroNotEqual(ref sub) => Tree::Unary(sub),
             AndV(ref left, ref right)
@@ -93,6 +95,7 @@ impl<'a, Pk: MiniscriptKey, Ctx: ScriptContext> TreeLike for &'a Terminal<Pk, Ct
             | Check(ref sub)
             | DupIf(ref sub)
             | Verify(ref sub)
+            | Drop(ref sub)
             | NonZero(ref sub)
             | ZeroNotEqual(ref sub) => Tree::Unary(sub.as_inner()),
             AndV(ref left, ref right)
diff --git a/src/miniscript/analyzable.rs b/src/miniscript/analyzable.rs
@@ -39,6 +39,8 @@ pub struct ExtParams {
     /// Allow parsing of miniscripts with raw pkh fragments without the pk.
     /// This could be obtained when parsing miniscript from script
     pub raw_pkh: bool,
+    /// Allow parsing of miniscripts with drop fragments (`r`)
+    pub drop: bool,
 }
 
 impl ExtParams {
@@ -51,6 +53,7 @@ impl ExtParams {
             malleability: false,
             repeated_pk: false,
             raw_pkh: false,
+            drop: false,
         }
     }
 
@@ -68,6 +71,7 @@ impl ExtParams {
             malleability: true,
             repeated_pk: true,
             raw_pkh: false,
+            drop: true,
         }
     }
 
@@ -80,6 +84,7 @@ impl ExtParams {
             malleability: true,
             repeated_pk: true,
             raw_pkh: true,
+            drop: true,
         }
     }
 
@@ -118,6 +123,11 @@ impl ExtParams {
         self.raw_pkh = true;
         self
     }
+
+    pub fn drop(mut self) -> ExtParams {
+        self.drop = true;
+        self
+    }
 }
 
 /// Possible reasons Miniscript guarantees can fail
@@ -143,6 +153,8 @@ pub enum AnalysisError {
     Malleable,
     /// Contains partial descriptor raw pkh
     ContainsRawPkh,
+    /// Contains a drop fragment
+    ContainsDrop,
 }
 
 impl fmt::Display for AnalysisError {
@@ -162,6 +174,7 @@ impl fmt::Display for AnalysisError {
             }
             AnalysisError::Malleable => f.write_str("Miniscript is malleable"),
             AnalysisError::ContainsRawPkh => f.write_str("Miniscript contains raw pkh"),
+            AnalysisError::ContainsDrop => f.write_str("Miniscript contains drop fragment"),
         }
     }
 }
@@ -177,7 +190,7 @@ impl error::Error for AnalysisError {
             | BranchExceedResouceLimits
             | HeightTimelockCombination
             | Malleable
-            | ContainsRawPkh => None,
+            | ContainsRawPkh | ContainsDrop => None,
         }
     }
 }
@@ -213,6 +226,10 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
         self.iter().any(|ms| matches!(ms.node, Terminal::RawPkH(_)))
     }
 
+    pub fn contains_drop(&self) -> bool {
+        self.iter().any(|ms| matches!(ms.node, Terminal::Drop(_)))
+    }
+
     /// Check whether the underlying Miniscript is safe under the current context
     /// Lifting these polices would create a semantic representation that does
     /// not represent the underlying semantics when miniscript is spent.
@@ -252,6 +269,8 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
             Err(AnalysisError::HeightTimelockCombination)
         } else if !ext.raw_pkh && self.contains_raw_pkh() {
             Err(AnalysisError::ContainsRawPkh)
+        } else if !ext.drop && self.contains_drop() {
+            Err(AnalysisError::ContainsDrop)
         } else {
             Ok(())
         }
diff --git a/src/miniscript/astelem.rs b/src/miniscript/astelem.rs
@@ -193,6 +193,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
                 .push_astelem(sub)
                 .push_opcode(opcodes::all::OP_ENDIF),
             Terminal::Verify(ref sub) => builder.push_astelem(sub).push_verify(),
+            Terminal::Drop(ref sub) => builder.push_astelem(sub).push_opcode(opcodes::all::OP_DROP),
             Terminal::NonZero(ref sub) => builder
                 .push_opcode(opcodes::all::OP_SIZE)
                 .push_opcode(opcodes::all::OP_0NOTEQUAL)
diff --git a/src/miniscript/decode.rs b/src/miniscript/decode.rs
@@ -90,6 +90,7 @@ enum NonTerm {
     Check,
     DupIf,
     Verify,
+    Drop,
     NonZero,
     ZeroNotEqual,
     AndV,
@@ -156,6 +157,8 @@ pub enum Terminal<Pk: MiniscriptKey, Ctx: ScriptContext> {
     DupIf(Arc<Miniscript<Pk, Ctx>>),
     /// `[T] VERIFY`
     Verify(Arc<Miniscript<Pk, Ctx>>),
+    /// `[T] DROP`
+    Drop(Arc<Miniscript<Pk, Ctx>>),
     /// `SIZE 0NOTEQUAL IF [Fn] ENDIF`
     NonZero(Arc<Miniscript<Pk, Ctx>>),
     /// `[X] 0NOTEQUAL`
@@ -207,6 +210,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Clone for Terminal<Pk, Ctx> {
             Terminal::Check(ref sub) => Terminal::Check(Arc::new(Miniscript::clone(sub))),
             Terminal::DupIf(ref sub) => Terminal::DupIf(Arc::new(Miniscript::clone(sub))),
             Terminal::Verify(ref sub) => Terminal::Verify(Arc::new(Miniscript::clone(sub))),
+            Terminal::Drop(ref sub) => Terminal::Drop(Arc::new(Miniscript::clone(sub))),
             Terminal::NonZero(ref sub) => Terminal::NonZero(Arc::new(Miniscript::clone(sub))),
             Terminal::ZeroNotEqual(ref sub) => {
                 Terminal::ZeroNotEqual(Arc::new(Miniscript::clone(sub)))
@@ -460,6 +464,10 @@ pub fn parse<Ctx: ScriptContext>(
                             non_term.push(NonTerm::Expression);
                         },
                     ),
+                    Tk::Drop => {
+                        non_term.push(NonTerm::Drop);
+                        non_term.push(NonTerm::Expression);
+                    },
                     Tk::ZeroNotEqual => {
                         non_term.push(NonTerm::ZeroNotEqual);
                         non_term.push(NonTerm::Expression);
@@ -612,6 +620,7 @@ pub fn parse<Ctx: ScriptContext>(
             Some(NonTerm::Check) => term.reduce1(Terminal::Check)?,
             Some(NonTerm::DupIf) => term.reduce1(Terminal::DupIf)?,
             Some(NonTerm::Verify) => term.reduce1(Terminal::Verify)?,
+            Some(NonTerm::Drop) => term.reduce1(Terminal::Drop)?,
             Some(NonTerm::NonZero) => term.reduce1(Terminal::NonZero)?,
             Some(NonTerm::ZeroNotEqual) => term.reduce1(Terminal::ZeroNotEqual)?,
             Some(NonTerm::AndV) => {
diff --git a/src/miniscript/display.rs b/src/miniscript/display.rs
@@ -82,6 +82,7 @@ impl<'a, Pk: MiniscriptKey, Ctx: ScriptContext> TreeLike for DisplayNode<'a, Pk,
                 | Terminal::Swap(ref sub)
                 | Terminal::DupIf(ref sub)
                 | Terminal::Verify(ref sub)
+                | Terminal::Drop(ref sub)
                 | Terminal::NonZero(ref sub)
                 | Terminal::ZeroNotEqual(ref sub) => {
                     Tree::Unary(DisplayNode::Node(sub.ty, sub.as_inner()))
@@ -256,6 +257,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Terminal<Pk, Ctx> {
             Terminal::Check(..) => "c",
             Terminal::DupIf(..) => "d",
             Terminal::Verify(..) => "v",
+            Terminal::Drop(..) => "r",
             Terminal::NonZero(..) => "j",
             Terminal::ZeroNotEqual(..) => "n",
             Terminal::AndV(_, ref r) if matches!(r.as_inner(), Terminal::True) => "t",
diff --git a/src/miniscript/mod.rs b/src/miniscript/mod.rs
@@ -103,6 +103,7 @@ mod private {
                     Terminal::Check(..) => Terminal::Check(stack.pop().unwrap()),
                     Terminal::DupIf(..) => Terminal::DupIf(stack.pop().unwrap()),
                     Terminal::Verify(..) => Terminal::Verify(stack.pop().unwrap()),
+                    Terminal::Drop(..) => Terminal::Drop(stack.pop().unwrap()),
                     Terminal::NonZero(..) => Terminal::NonZero(stack.pop().unwrap()),
                     Terminal::ZeroNotEqual(..) => Terminal::ZeroNotEqual(stack.pop().unwrap()),
                     Terminal::AndV(..) => {
@@ -236,6 +237,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
                 Terminal::After(n) => script_num_size(n.to_consensus_u32() as usize) + 1,
                 Terminal::Older(n) => script_num_size(n.to_consensus_u32() as usize) + 1,
                 Terminal::Verify(ref sub) => usize::from(!sub.ext.has_free_verify),
+                Terminal::Drop(..) => 1,
                 Terminal::Thresh(ref thresh) => {
                     script_num_size(thresh.k()) // k
                         + 1 // EQUAL
@@ -553,6 +555,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
                 Terminal::Check(..) => Terminal::Check(translated.pop().unwrap()),
                 Terminal::DupIf(..) => Terminal::DupIf(translated.pop().unwrap()),
                 Terminal::Verify(..) => Terminal::Verify(translated.pop().unwrap()),
+                Terminal::Drop(..) => Terminal::Drop(translated.pop().unwrap()),
                 Terminal::NonZero(..) => Terminal::NonZero(translated.pop().unwrap()),
                 Terminal::ZeroNotEqual(..) => Terminal::ZeroNotEqual(translated.pop().unwrap()),
                 Terminal::AndV(..) => {
@@ -618,6 +621,7 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {
                 Terminal::Check(..) => Terminal::Check(stack.pop().unwrap()),
                 Terminal::DupIf(..) => Terminal::DupIf(stack.pop().unwrap()),
                 Terminal::Verify(..) => Terminal::Verify(stack.pop().unwrap()),
+                Terminal::Drop(..) => Terminal::Drop(stack.pop().unwrap()),
                 Terminal::NonZero(..) => Terminal::NonZero(stack.pop().unwrap()),
                 Terminal::ZeroNotEqual(..) => Terminal::ZeroNotEqual(stack.pop().unwrap()),
                 Terminal::AndV(..) => Terminal::AndV(stack.pop().unwrap(), stack.pop().unwrap()),
@@ -729,6 +733,7 @@ where
             'c' => unwrapped = Terminal::Check(Arc::new(ms)),
             'd' => unwrapped = Terminal::DupIf(Arc::new(ms)),
             'v' => unwrapped = Terminal::Verify(Arc::new(ms)),
+            'r' => unwrapped = Terminal::Drop(Arc::new(ms)),
             'j' => unwrapped = Terminal::NonZero(Arc::new(ms)),
             'n' => unwrapped = Terminal::ZeroNotEqual(Arc::new(ms)),
             't' => unwrapped = Terminal::AndV(Arc::new(ms), Arc::new(Miniscript::TRUE)),
@@ -1202,6 +1207,9 @@ mod tests {
         assert_eq!(abs.minimum_n_keys(), Some(3));
 
         roundtrip(&ms_str!("older(921)"), "OP_PUSHBYTES_2 9903 OP_CSV");
+        roundtrip(&ms_str!("and_v(r:after(1024),1)"), "OP_PUSHBYTES_2 0004 OP_CLTV OP_DROP OP_PUSHNUM_1");
+        roundtrip(&ms_str!("and_v(r:older(1024),1)"), "OP_PUSHBYTES_2 0004 OP_CSV OP_DROP OP_PUSHNUM_1");
+        roundtrip(&ms_str!("and_v(r:1,1)"), "OP_PUSHNUM_1 OP_DROP OP_PUSHNUM_1");
 
         roundtrip(
             &ms_str!("sha256({})",sha256::Hash::hash(&[])),
@@ -1461,6 +1469,41 @@ mod tests {
         assert!(ms_str.is_err());
     }
 
+    #[test]
+    fn drop_wrapper() {
+        type SwMs = Miniscript<String, Segwitv0>;
+        fn assert_error(s: &str, expected_error: Option<&str>) {
+            match SwMs::from_str_insane(&s) {
+                Ok(_) => match expected_error {
+                    Some(e) => {
+                        panic!("Expected error: {}", e);
+                    }
+                    None => {
+                        // do nothing
+                    }
+                },
+                Err(e1) => match expected_error {
+                    Some(e2) => assert_eq!(e1.to_string(), e2.to_string()),
+                    None => { panic!("Unexpected error: {}", e1); }
+                },
+            }
+        }
+
+        {
+            assert_error("and_v(r:after(1024),1)", None);
+        }
+
+        {
+
+            fn assert_error_cannot_wrap(s: &str, prefix: &str) {
+                let err_cannot_wrap = format!("typecheck: fragment «{}:after(1024)» cannot wrap a fragment of type V", prefix);
+                assert_error(s, Some(&err_cannot_wrap));
+            }
+            assert_error_cannot_wrap("and_v(rr:after(1024),1)", "rr");
+            assert_error_cannot_wrap("and_v(rv:after(1024),1)", "rv");
+        }
+    }
+
     #[test]
     fn translate_tests() {
         let ms = Miniscript::<String, Segwitv0>::from_str("pk(A)").unwrap();
diff --git a/src/miniscript/ms_tests.rs b/src/miniscript/ms_tests.rs
@@ -8,7 +8,7 @@
 #[cfg(test)]
 mod tests {
     use core::fmt;
-
+    use core::str::FromStr;
     use crate::miniscript::types;
     use crate::{Miniscript, Segwitv0};
 
@@ -15047,6 +15047,7 @@ mod tests {
     #[cfg_attr(feature="cargo-fmt", rustfmt_skip)]
     fn malleable_tests_from_alloy() {
         ms_test("and_v(v:after(500000001),or_d(j:multi(2,A,B,C),multi(2,D,E,F)))", "usB");
+        ms_test("and_v(r:after(500000001),or_d(j:multi(2,A,B,C),multi(2,D,E,F)))", "usB");
         ms_test("or_b(j:multi(2,A,B,C),a:andor(multi(2,D,E,F),multi(2,G,I,J),multi(2,K,L,M)))", "dBesu");
         ms_test("andor(or_i(multi(2,A,B,C),0),sha256(c7bcb868ab4db55ca45f8eefe5b1677d9fc2c4111e295baaee1b34ed352c719b),multi(2,D,E,F))", "dBesu");
         ms_test("or_d(or_i(0,or_i(multi(2,A,B,C),0)),multi(2,D,E,F))", "dBesu");
@@ -23855,4 +23856,10 @@ mod tests {
 
         }
     }
+
+    #[test]
+    pub fn test_opdrop() {
+        Miniscript::<String, Segwitv0>::from_str("and_v(v:after(100000),multi(1,A,B))").unwrap();
+        let ms: Miniscript<String, Segwitv0> = Miniscript::from_str("and_v(v:after(100000),multi(1,A,B))").unwrap();
+    }
 }
diff --git a/src/miniscript/satisfy.rs b/src/miniscript/satisfy.rs
@@ -1338,6 +1338,7 @@ impl<Pk: MiniscriptKey + ToPublicKey> Satisfaction<Placeholder<Pk>> {
             | Terminal::Swap(ref sub)
             | Terminal::Check(ref sub)
             | Terminal::Verify(ref sub)
+            | Terminal::Drop(ref sub)
             | Terminal::NonZero(ref sub)
             | Terminal::ZeroNotEqual(ref sub) => {
                 Self::satisfy_helper(&sub.node, stfr, root_has_sig, leaf_hash, min_fn, thresh_fn)
@@ -1647,6 +1648,7 @@ impl<Pk: MiniscriptKey + ToPublicKey> Satisfaction<Placeholder<Pk>> {
             | Terminal::Older(_)
             | Terminal::After(_)
             | Terminal::Verify(_)
+            | Terminal::Drop(_)
             | Terminal::OrC(..) => Satisfaction {
                 stack: Witness::Impossible,
                 has_sig: false,
diff --git a/src/miniscript/types/correctness.rs b/src/miniscript/types/correctness.rs
@@ -238,6 +238,19 @@ impl Correctness {
         })
     }
 
+    /// Constructor for the correctness properties of the `r:` fragment.
+    pub const fn cast_drop(self) -> Result<Self, ErrorKind> {
+        // from https://bitcoin.sipa.be/miniscript/:
+        // > Every miniscript expression has one of four basic types:
+        // > ...
+        // > "V" Verify expressions. Like "B", these take their inputs from the top of the stack.
+        // > Upon satisfaction however, they continue without pushing anything.
+        // > They cannot be dissatisfied (will abort instead).
+        // So while OP_DROP doesn't actually verify anything, the closest type is still `V`.
+        // We delegate to `cast_verify` to handle the rest of the properties.
+        Self::cast_verify(self)
+    }
+
     /// Constructor for the correctness properties of the `j:` fragment.
     pub const fn cast_nonzero(self) -> Result<Self, ErrorKind> {
         if !self.input.constfn_eq(Input::OneNonZero) && !self.input.constfn_eq(Input::AnyNonZero) {
diff --git a/src/miniscript/types/extra_props.rs b/src/miniscript/types/extra_props.rs
@@ -488,6 +488,12 @@ impl ExtData {
         }
     }
 
+    /// Extra properties for the `r:` fragment.
+    pub fn cast_drop(self) -> Self {
+        // delegate to `cast_verify` as the properties are the same
+        self.cast_verify()
+    }
+
     /// Extra properties for the `j:` fragment.
     pub const fn cast_nonzero(self) -> Self {
         ExtData {
@@ -947,6 +953,7 @@ impl ExtData {
             Terminal::Check(ref sub) => Self::cast_check(sub.ext),
             Terminal::DupIf(ref sub) => Self::cast_dupif(sub.ext),
             Terminal::Verify(ref sub) => Self::cast_verify(sub.ext),
+            Terminal::Drop(ref sub) => Self::cast_drop(sub.ext),
             Terminal::NonZero(ref sub) => Self::cast_nonzero(sub.ext),
             Terminal::ZeroNotEqual(ref sub) => Self::cast_zeronotequal(sub.ext),
             Terminal::AndB(ref l, ref r) => {
diff --git a/src/miniscript/types/malleability.rs b/src/miniscript/types/malleability.rs
@@ -141,11 +141,17 @@ impl Malleability {
         }
     }
 
-    /// Constructor for the malleabilitiy properties of the `v:` fragment.
+    /// Constructor for the malleability properties of the `v:` fragment.
     pub const fn cast_verify(self) -> Self {
         Malleability { dissat: Dissat::None, safe: self.safe, non_malleable: self.non_malleable }
     }
 
+    /// Constructor for the malleability properties of the `r:` fragment.
+    pub const fn cast_drop(self) -> Self {
+        // delegate to `cast_verify()`
+        self.cast_verify()
+    }
+
     /// Constructor for the malleabilitiy properties of the `j:` fragment.
     pub const fn cast_nonzero(self) -> Self {
         Malleability {
diff --git a/src/miniscript/types/mod.rs b/src/miniscript/types/mod.rs
diff --git a/src/policy/compiler.rs b/src/policy/compiler.rs
diff --git a/src/policy/mod.rs b/src/policy/mod.rs
diff --git a/src/psbt/mod.rs b/src/psbt/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -682,13 +682,13 @@ where`
`682`	`682`	`Terminal::DupIf(ref _sub) if node_state.n_evaluated == 1 => {`
`683`	`683`	`self.stack.push(stack::Element::Satisfied);`
`684`	`684`	`}`
`685`		`- Terminal::ZeroNotEqual(ref sub) \| Terminal::Verify(ref sub)`
	`685`	`+ Terminal::ZeroNotEqual(ref sub) \| Terminal::Verify(ref sub) \| Terminal::Drop(ref sub)`
`686`	`686`	`if node_state.n_evaluated == 0 =>`
`687`	`687`	`{`
`688`	`688`	`self.push_evaluation_state(node_state.node, 1, 0);`
`689`	`689`	`self.push_evaluation_state(sub, 0, 0);`
`690`	`690`	`}`
`691`		`- Terminal::Verify(ref _sub) if node_state.n_evaluated == 1 => {`
	`691`	`+ Terminal::Verify(ref _sub) \| Terminal::Drop(ref _sub) if node_state.n_evaluated == 1 => {`
`692`	`692`	`match self.stack.pop() {`
`693`	`693`	`Some(stack::Element::Satisfied) => (),`
`694`	`694`	`Some(_) => return Some(Err(Error::VerifyFailed)),`
Original file line number	Diff line number	Diff line change
`@@ -39,6 +39,8 @@ pub struct ExtParams {`
`39`	`39`	`/// Allow parsing of miniscripts with raw pkh fragments without the pk.`
`40`	`40`	`/// This could be obtained when parsing miniscript from script`
`41`	`41`	`pub raw_pkh: bool,`
	`42`	+ /// Allow parsing of miniscripts with drop fragments (`r`)
	`43`	`+ pub drop: bool,`
`42`	`44`	`}`
`43`	`45`
`44`	`46`	`impl ExtParams {`
`@@ -51,6 +53,7 @@ impl ExtParams {`
`51`	`53`	`malleability: false,`
`52`	`54`	`repeated_pk: false,`
`53`	`55`	`raw_pkh: false,`
	`56`	`+ drop: false,`
`54`	`57`	`}`
`55`	`58`	`}`
`56`	`59`
`@@ -68,6 +71,7 @@ impl ExtParams {`
`68`	`71`	`malleability: true,`
`69`	`72`	`repeated_pk: true,`
`70`	`73`	`raw_pkh: false,`
	`74`	`+ drop: true,`
`71`	`75`	`}`
`72`	`76`	`}`
`73`	`77`
`@@ -80,6 +84,7 @@ impl ExtParams {`
`80`	`84`	`malleability: true,`
`81`	`85`	`repeated_pk: true,`
`82`	`86`	`raw_pkh: true,`
	`87`	`+ drop: true,`
`83`	`88`	`}`
`84`	`89`	`}`
`85`	`90`
`@@ -118,6 +123,11 @@ impl ExtParams {`
`118`	`123`	`self.raw_pkh = true;`
`119`	`124`	`self`
`120`	`125`	`}`
	`126`	`+`
	`127`	`+ pub fn drop(mut self) -> ExtParams {`
	`128`	`+ self.drop = true;`
	`129`	`+ self`
	`130`	`+ }`
`121`	`131`	`}`
`122`	`132`
`123`	`133`	`/// Possible reasons Miniscript guarantees can fail`
`@@ -143,6 +153,8 @@ pub enum AnalysisError {`
`143`	`153`	`Malleable,`
`144`	`154`	`/// Contains partial descriptor raw pkh`
`145`	`155`	`ContainsRawPkh,`
	`156`	`+ /// Contains a drop fragment`
	`157`	`+ ContainsDrop,`
`146`	`158`	`}`
`147`	`159`
`148`	`160`	`impl fmt::Display for AnalysisError {`
`@@ -162,6 +174,7 @@ impl fmt::Display for AnalysisError {`
`162`	`174`	`}`
`163`	`175`	`AnalysisError::Malleable => f.write_str("Miniscript is malleable"),`
`164`	`176`	`AnalysisError::ContainsRawPkh => f.write_str("Miniscript contains raw pkh"),`
	`177`	`+ AnalysisError::ContainsDrop => f.write_str("Miniscript contains drop fragment"),`
`165`	`178`	`}`
`166`	`179`	`}`
`167`	`180`	`}`
`@@ -177,7 +190,7 @@ impl error::Error for AnalysisError {`
`177`	`190`	`\| BranchExceedResouceLimits`
`178`	`191`	`\| HeightTimelockCombination`
`179`	`192`	`\| Malleable`
`180`		`- \| ContainsRawPkh => None,`
	`193`	`+ \| ContainsRawPkh \| ContainsDrop => None,`
`181`	`194`	`}`
`182`	`195`	`}`
`183`	`196`	`}`
`@@ -213,6 +226,10 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {`
`213`	`226`	`self.iter().any(\|ms\| matches!(ms.node, Terminal::RawPkH(_)))`
`214`	`227`	`}`
`215`	`228`
	`229`	`+ pub fn contains_drop(&self) -> bool {`
	`230`	`+ self.iter().any(\|ms\| matches!(ms.node, Terminal::Drop(_)))`
	`231`	`+ }`
	`232`	`+`
`216`	`233`	`/// Check whether the underlying Miniscript is safe under the current context`
`217`	`234`	`/// Lifting these polices would create a semantic representation that does`
`218`	`235`	`/// not represent the underlying semantics when miniscript is spent.`
`@@ -252,6 +269,8 @@ impl<Pk: MiniscriptKey, Ctx: ScriptContext> Miniscript<Pk, Ctx> {`
`252`	`269`	`Err(AnalysisError::HeightTimelockCombination)`
`253`	`270`	`} else if !ext.raw_pkh && self.contains_raw_pkh() {`
`254`	`271`	`Err(AnalysisError::ContainsRawPkh)`
	`272`	`+ } else if !ext.drop && self.contains_drop() {`
	`273`	`+ Err(AnalysisError::ContainsDrop)`
`255`	`274`	`} else {`
`256`	`275`	`Ok(())`
`257`	`276`	`}`