Merge ElementsProject#28: Add num64_ prefix to comparison ops

85ed5f3 Fix decoding bug while implementing CurrInputValue (sanket1729)
c6dfc12 This fix has a bunch of bug fixes. (sanket1729)
2a5455a Mark has_free_verify more CurrIndEq (sanket1729)
6029aba Add num64_ prefix to comparison ops (sanket1729)

Pull request description:

  Followup to ElementsProject#27

ACKs for top commit:
  apoelstra:
    ACK 85ed5f3

Tree-SHA512: db31d2a9f818be80b4cc3cc1744d2f3b587ed2f14e7b63812515ec5d22300dd86664318198231bfb701dbb4df0bfeba9a1c2c0677ad82f9e8e2a006364d10806

Author: sanket1729

doc/extension_spec.md

@@ -44,13 +44,13 @@ To use these with miniscript fragments, we can use them inside comparison extens
 
 Name                                    | Script
 ---                                     | ---
-num_eq(NumExpr_X,NumExpr_Y)             | `[NumExpr_X] [NumExpr_Y] EQUAL64`
-le(NumExpr_X,NumExpr_Y)                 | `[NumExpr_X] [NumExpr_Y] LESSTHAN64`
-ge(NumExpr_X,NumExpr_Y)                 | `[NumExpr_X] [NumExpr_Y] GREATERTHAN64`
-leq(NumExpr_X,NumExpr_Y)                | `[NumExpr_X] [NumExpr_Y] LESSTHANOREQUAL64`
-geq(NumExpr_X,NumExpr_Y)                | `[NumExpr_X] [NumExpr_Y] GREATERTHANOREQUAL64`
+num64_eq(NumExpr_X,NumExpr_Y)           | `[NumExpr_X] [NumExpr_Y] EQUAL`
+num64_le(NumExpr_X,NumExpr_Y)           | `[NumExpr_X] [NumExpr_Y] LESSTHAN64`
+num64_ge(NumExpr_X,NumExpr_Y)           | `[NumExpr_X] [NumExpr_Y] GREATERTHAN64`
+num64_leq(NumExpr_X,NumExpr_Y)          | `[NumExpr_X] [NumExpr_Y] LESSTHANOREQUAL64`
+num64_geq(NumExpr_X,NumExpr_Y)          | `[NumExpr_X] [NumExpr_Y] GREATERTHANOREQUAL64`
 
-- For example, `num_eq(inp_v(1),mul(curr_inp_v,20))` represents second input value is the multiplication of
+- For example, `num64_eq(inp_v(1),mul(curr_inp_v,20))` represents second input value is the multiplication of
 current input value and fourth output value. This would abort if any of the values are confidential.
 
 ### Tx Value introspection

src/extensions/arith.rs

@@ -476,9 +476,7 @@ impl Expr {
         } else if let Some(&[Tk::CurrInp, Tk::InpValue, Tk::Num(1), Tk::Equal, Tk::Verify]) =
             tks.get(e.checked_sub(5)?..e)
         {
-            let (x, end_pos) = Self::from_tokens(tokens, e - 5)?;
-            let expr = Expr::from_inner(ExprInner::Negate(Box::new(x)));
-            Some((expr, end_pos))
+            Some((Expr::from_inner(ExprInner::CurrInputIdx), e - 5))
         } else if let Some(&[Tk::Div64, Tk::Num(1), Tk::Equal, Tk::Verify, Tk::Nip]) =
             tks.get(e.checked_sub(5)?..e)
         {
@@ -526,15 +524,15 @@ pub enum Arith {
     /// Eq
     /// [X] [Y] EQUAL
     Eq(Expr, Expr),
-    /// Le
+    /// Lt
     /// [X] [Y] LESSTHAN
-    Le(Expr, Expr),
+    Lt(Expr, Expr),
     /// Leq
     /// [X] [Y] LESSTHANOREQUAL
     Leq(Expr, Expr),
-    /// Ge
+    /// Gt
     /// [X] [Y] GREATERTHAN
-    Ge(Expr, Expr),
+    Gt(Expr, Expr),
     /// Geq
     /// [X] [Y] GREATERTHANOREQUAL
     Geq(Expr, Expr),
@@ -545,9 +543,9 @@ impl Arith {
     pub fn depth(&self) -> usize {
         match self {
             Arith::Eq(x, y)
-            | Arith::Le(x, y)
+            | Arith::Lt(x, y)
             | Arith::Leq(x, y)
-            | Arith::Ge(x, y)
+            | Arith::Gt(x, y)
             | Arith::Geq(x, y) => cmp::max(x.depth, y.depth),
         }
     }
@@ -556,9 +554,9 @@ impl Arith {
     pub fn script_size(&self) -> usize {
         match self {
             Arith::Eq(x, y)
-            | Arith::Le(x, y)
+            | Arith::Lt(x, y)
             | Arith::Leq(x, y)
-            | Arith::Ge(x, y)
+            | Arith::Gt(x, y)
             | Arith::Geq(x, y) => x.script_size + y.script_size + 1,
         }
     }
@@ -572,9 +570,9 @@ impl Arith {
     ) -> Result<bool, EvalError> {
         let res = match self {
             Arith::Eq(x, y) => x.eval(curr_ind, tx, utxos)? == y.eval(curr_ind, tx, utxos)?,
-            Arith::Le(x, y) => x.eval(curr_ind, tx, utxos)? < y.eval(curr_ind, tx, utxos)?,
+            Arith::Lt(x, y) => x.eval(curr_ind, tx, utxos)? < y.eval(curr_ind, tx, utxos)?,
             Arith::Leq(x, y) => x.eval(curr_ind, tx, utxos)? <= y.eval(curr_ind, tx, utxos)?,
-            Arith::Ge(x, y) => x.eval(curr_ind, tx, utxos)? > y.eval(curr_ind, tx, utxos)?,
+            Arith::Gt(x, y) => x.eval(curr_ind, tx, utxos)? > y.eval(curr_ind, tx, utxos)?,
             Arith::Geq(x, y) => x.eval(curr_ind, tx, utxos)? >= y.eval(curr_ind, tx, utxos)?,
         };
         Ok(res)
@@ -588,7 +586,7 @@ impl Arith {
                 let builder = y.push_to_builder(builder);
                 builder.push_opcode(OP_EQUAL)
             }
-            Arith::Le(x, y) => {
+            Arith::Lt(x, y) => {
                 let builder = x.push_to_builder(builder);
                 let builder = y.push_to_builder(builder);
                 builder.push_opcode(OP_LESSTHAN64)
@@ -598,7 +596,7 @@ impl Arith {
                 let builder = y.push_to_builder(builder);
                 builder.push_opcode(OP_LESSTHANOREQUAL64)
             }
-            Arith::Ge(x, y) => {
+            Arith::Gt(x, y) => {
                 let builder = x.push_to_builder(builder);
                 let builder = y.push_to_builder(builder);
                 builder.push_opcode(OP_GREATERTHAN64)
@@ -623,9 +621,9 @@ impl Arith {
         let (x, pos) = Expr::from_tokens(tokens, pos)?;
         match last_opcode {
             Tk::Equal => Some((Self::Eq(x, y), pos)),
-            Tk::Le64 => Some((Self::Le(x, y), pos)),
+            Tk::Le64 => Some((Self::Lt(x, y), pos)),
             Tk::Leq64 => Some((Self::Leq(x, y), pos)),
-            Tk::Ge64 => Some((Self::Ge(x, y), pos)),
+            Tk::Ge64 => Some((Self::Gt(x, y), pos)),
             Tk::Geq64 => Some((Self::Geq(x, y), pos)),
             _ => None,
         }
@@ -770,12 +768,12 @@ impl FromTree for Box<Arith> {
 impl FromTree for Arith {
     fn from_tree(top: &expression::Tree<'_>) -> Result<Self, Error> {
         match (top.name, top.args.len()) {
-            // Disambiguiate with num_eq to avoid confusion with asset_eq
-            ("num_eq", 2) => expression::binary(top, Arith::Eq),
-            ("geq", 2) => expression::binary(top, Arith::Geq),
-            ("ge", 2) => expression::binary(top, Arith::Ge),
-            ("le", 2) => expression::binary(top, Arith::Le),
-            ("leq", 2) => expression::binary(top, Arith::Leq),
+            // Disambiguiate with num64_eq to avoid confusion with asset_eq
+            ("num64_eq", 2) => expression::binary(top, Arith::Eq),
+            ("num64_geq", 2) => expression::binary(top, Arith::Geq),
+            ("num64_gt", 2) => expression::binary(top, Arith::Gt),
+            ("num64_lt", 2) => expression::binary(top, Arith::Lt),
+            ("num64_leq", 2) => expression::binary(top, Arith::Leq),
             _ => Err(Error::Unexpected(format!(
                 "{}({} args) while parsing Extension",
                 top.name,
@@ -788,23 +786,23 @@ impl FromTree for Arith {
 impl fmt::Display for Arith {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match &self {
-            Arith::Eq(x, y) => write!(f, "num_eq({},{})", x, y),
-            Arith::Leq(x, y) => write!(f, "leq({},{})", x, y),
-            Arith::Le(x, y) => write!(f, "le({},{})", x, y),
-            Arith::Geq(x, y) => write!(f, "geq({},{})", x, y),
-            Arith::Ge(x, y) => write!(f, "ge({},{})", x, y),
+            Arith::Eq(x, y) => write!(f, "num64_eq({},{})", x, y),
+            Arith::Leq(x, y) => write!(f, "num64_leq({},{})", x, y),
+            Arith::Lt(x, y) => write!(f, "num64_lt({},{})", x, y),
+            Arith::Geq(x, y) => write!(f, "num64_geq({},{})", x, y),
+            Arith::Gt(x, y) => write!(f, "num64_gt({},{})", x, y),
         }
     }
 }
 
 impl fmt::Debug for Arith {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match &self {
-            Arith::Eq(x, y) => write!(f, "num_eq({:?},{:?})", x, y),
-            Arith::Leq(x, y) => write!(f, "leq({:?},{:?})", x, y),
-            Arith::Le(x, y) => write!(f, "le({:?},{:?})", x, y),
-            Arith::Geq(x, y) => write!(f, "geq({:?},{:?})", x, y),
-            Arith::Ge(x, y) => write!(f, "ge({:?},{:?})", x, y),
+            Arith::Eq(x, y) => write!(f, "num64_eq({:?},{:?})", x, y),
+            Arith::Leq(x, y) => write!(f, "num64_leq({:?},{:?})", x, y),
+            Arith::Lt(x, y) => write!(f, "num64_lt({:?},{:?})", x, y),
+            Arith::Geq(x, y) => write!(f, "num64_geq({:?},{:?})", x, y),
+            Arith::Gt(x, y) => write!(f, "num64_gt({:?},{:?})", x, y),
         }
     }
 }
@@ -1064,38 +1062,41 @@ mod tests {
 
     #[test]
     fn arith_parse() {
+        _arith_parse("num64_gt(curr_inp_v,mul(1,out_v(0)))");
         // This does not test the evaluation
-        _arith_parse("num_eq(8,8)");
-        _arith_parse("ge(9223372036854775807,9223372036854775806)"); // 2**63-1
+        _arith_parse("num64_eq(8,8)");
+        _arith_parse("num64_gt(9223372036854775807,9223372036854775806)"); // 2**63-1
 
         // negatives and comparisons
-        _arith_parse("num_eq(-8,-8)"); // negative nums
-        _arith_parse("ge(-8,-9)");
-        _arith_parse("geq(-8,-8)");
-        _arith_parse("leq(-8,-7)");
-        _arith_parse("le(-8,-7)");
+        _arith_parse("num64_eq(-8,-8)"); // negative nums
+        _arith_parse("num64_gt(-8,-9)");
+        _arith_parse("num64_geq(-8,-8)");
+        _arith_parse("num64_leq(-8,-7)");
+        _arith_parse("num64_lt(-8,-7)");
 
         // test terminals parsing
-        _arith_parse("num_eq(inp_v(0),100)");
-        _arith_parse("num_eq(out_v(0),100)");
-        _arith_parse("num_eq(inp_issue_v(0),100)");
-        _arith_parse("num_eq(inp_reissue_v(0),100)");
-        _arith_parse("num_eq(inp_v(0),out_v(0))");
-        _arith_parse("num_eq(inp_issue_v(1),inp_reissue_v(1))");
+        _arith_parse("num64_eq(inp_v(0),100)");
+        _arith_parse("num64_eq(out_v(0),100)");
+        _arith_parse("num64_eq(inp_issue_v(0),100)");
+        _arith_parse("num64_eq(inp_reissue_v(0),100)");
+        _arith_parse("num64_eq(inp_v(0),out_v(0))");
+        _arith_parse("num64_eq(inp_issue_v(1),inp_reissue_v(1))");
 
         // test combinator
-        _arith_parse("num_eq(add(4,3),mul(1,7))");
-        _arith_parse("num_eq(sub(3,3),div(0,9))");
-        _arith_parse("num_eq(mod(9,3),0)");
-        _arith_parse("num_eq(bitand(0,134),0)");
-        _arith_parse("num_eq(bitor(1,3),3)");
-        _arith_parse("num_eq(bitxor(1,3),2)");
-        _arith_parse("num_eq(bitinv(0),-9223372036854775808)");
-        _arith_parse("num_eq(neg(1),-1)");
+        _arith_parse("num64_eq(add(4,3),mul(1,7))");
+        _arith_parse("num64_eq(sub(3,3),div(0,9))");
+        _arith_parse("num64_eq(mod(9,3),0)");
+        _arith_parse("num64_eq(bitand(0,134),0)");
+        _arith_parse("num64_eq(bitor(1,3),3)");
+        _arith_parse("num64_eq(bitxor(1,3),2)");
+        _arith_parse("num64_eq(bitinv(0),-9223372036854775808)");
+        _arith_parse("num64_eq(neg(1),-1)");
 
         // test some misc combinations with other miniscript fragments
-        _arith_parse("and_v(v:pk(K),ge(8,7))");
-        _arith_parse("and_v(v:pk(K),num_eq(mul(inp_v(0),out_v(1)),sub(add(3,inp_issue_v(1)),-9)))");
+        _arith_parse("and_v(v:pk(K),num64_gt(8,7))");
+        _arith_parse(
+            "and_v(v:pk(K),num64_eq(mul(inp_v(0),out_v(1)),sub(add(3,inp_issue_v(1)),-9)))",
+        );
     }
 
     fn _arith_parse(s: &str) {

src/extensions/introspect_ops.rs

@@ -168,24 +168,22 @@ impl<T: ExtParam> fmt::Debug for AssetExpr<T> {
     }
 }
 
-impl<T: ExtParam> FromStr for AssetExpr<T> {
-    type Err = Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
+impl<T: ExtParam> ArgFromStr for AssetExpr<T> {
+    fn arg_from_str(s: &str, parent: &str, pos: usize) -> Result<Self, Error> {
         let top = expression::Tree::from_str(s)?;
-        Self::from_tree(&top)
+        Self::from_tree_parent(&top, parent, pos)
     }
 }
 
-impl<T: ExtParam> FromTree for AssetExpr<T> {
-    fn from_tree(top: &Tree<'_>) -> Result<Self, Error> {
+impl<T: ExtParam> AssetExpr<T> {
+    fn from_tree_parent(top: &Tree<'_>, parent: &str, pos: usize) -> Result<Self, Error> {
         match (top.name, top.args.len()) {
             ("curr_inp_asset", 0) => Ok(AssetExpr::CurrInputAsset),
             ("inp_asset", 1) => expression::terminal(&top.args[0], expression::parse_num::<usize>)
                 .map(AssetExpr::Input),
             ("out_asset", 1) => expression::terminal(&top.args[0], expression::parse_num::<usize>)
                 .map(AssetExpr::Output),
-            (asset, 0) => Ok(AssetExpr::Const(T::arg_from_str(asset, "", 0)?)),
+            (asset, 0) => Ok(AssetExpr::Const(T::arg_from_str(asset, parent, pos)?)),
             _ => Err(Error::Unexpected(format!(
                 "{}({} args) while parsing Extension",
                 top.name,
@@ -244,24 +242,22 @@ impl<T: ExtParam> fmt::Debug for ValueExpr<T> {
     }
 }
 
-impl<T: ExtParam> FromStr for ValueExpr<T> {
-    type Err = Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
+impl<T: ExtParam> ArgFromStr for ValueExpr<T> {
+    fn arg_from_str(s: &str, parent: &str, pos: usize) -> Result<Self, Error> {
         let top = expression::Tree::from_str(s)?;
-        Self::from_tree(&top)
+        Self::from_tree_parent(&top, parent, pos)
     }
 }
 
-impl<T: ExtParam> FromTree for ValueExpr<T> {
-    fn from_tree(top: &Tree<'_>) -> Result<Self, Error> {
+impl<T: ExtParam> ValueExpr<T> {
+    fn from_tree_parent(top: &Tree<'_>, parent: &str, pos: usize) -> Result<Self, Error> {
         match (top.name, top.args.len()) {
             ("curr_inp_value", 0) => Ok(ValueExpr::CurrInputValue),
             ("inp_value", 1) => expression::terminal(&top.args[0], expression::parse_num::<usize>)
                 .map(ValueExpr::Input),
             ("out_value", 1) => expression::terminal(&top.args[0], expression::parse_num::<usize>)
                 .map(ValueExpr::Output),
-            (value, 0) => Ok(ValueExpr::Const(T::arg_from_str(value, "", 0)?)),
+            (value, 0) => Ok(ValueExpr::Const(T::arg_from_str(value, parent, pos)?)),
             _ => Err(Error::Unexpected(format!(
                 "{}({} args) while parsing Extension",
                 top.name,
@@ -320,24 +316,22 @@ impl<T: ExtParam> fmt::Debug for SpkExpr<T> {
     }
 }
 
-impl<T: ExtParam> FromStr for SpkExpr<T> {
-    type Err = Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
+impl<T: ExtParam> ArgFromStr for SpkExpr<T> {
+    fn arg_from_str(s: &str, parent: &str, pos: usize) -> Result<Self, Error> {
         let top = expression::Tree::from_str(s)?;
-        Self::from_tree(&top)
+        Self::from_tree_parent(&top, parent, pos)
     }
 }
 
-impl<T: ExtParam> FromTree for SpkExpr<T> {
-    fn from_tree(top: &Tree<'_>) -> Result<Self, Error> {
+impl<T: ExtParam> SpkExpr<T> {
+    fn from_tree_parent(top: &Tree<'_>, parent: &str, pos: usize) -> Result<Self, Error> {
         match (top.name, top.args.len()) {
             ("curr_inp_spk", 0) => Ok(SpkExpr::CurrInputSpk),
             ("inp_spk", 1) => expression::terminal(&top.args[0], expression::parse_num::<usize>)
                 .map(SpkExpr::Input),
             ("out_spk", 1) => expression::terminal(&top.args[0], expression::parse_num::<usize>)
                 .map(SpkExpr::Output),
-            (asset, 0) => Ok(SpkExpr::Const(T::arg_from_str(asset, "", 0)?)),
+            (asset, 0) => Ok(SpkExpr::Const(T::arg_from_str(asset, parent, pos)?)),
             _ => Err(Error::Unexpected(format!(
                 "{}({} args) while parsing Extension",
                 top.name,
@@ -385,11 +379,27 @@ impl<T: ExtParam> FromStr for CovOps<T> {
 impl<T: ExtParam> FromTree for CovOps<T> {
     fn from_tree(top: &Tree<'_>) -> Result<Self, Error> {
         match (top.name, top.args.len()) {
-            ("is_exp_asset", 1) => expression::unary(top, CovOps::IsExpAsset),
-            ("is_exp_value", 1) => expression::unary(top, CovOps::IsExpValue),
-            ("asset_eq", 2) => expression::binary(top, CovOps::AssetEq),
-            ("value_eq", 2) => expression::binary(top, CovOps::ValueEq),
-            ("spk_eq", 2) => expression::binary(top, CovOps::SpkEq),
+            ("is_exp_asset", 1) => {
+                AssetExpr::from_tree_parent(&top.args[0], &top.name, 0).map(CovOps::IsExpAsset)
+            }
+            ("is_exp_value", 1) => {
+                ValueExpr::from_tree_parent(&top.args[0], &top.name, 0).map(CovOps::IsExpValue)
+            }
+            ("asset_eq", 2) => {
+                let l = AssetExpr::from_tree_parent(&top.args[0], &top.name, 0)?;
+                let r = AssetExpr::from_tree_parent(&top.args[1], &top.name, 1)?;
+                Ok(CovOps::AssetEq(l, r))
+            }
+            ("value_eq", 2) => {
+                let l = ValueExpr::from_tree_parent(&top.args[0], &top.name, 0)?;
+                let r = ValueExpr::from_tree_parent(&top.args[1], &top.name, 1)?;
+                Ok(CovOps::ValueEq(l, r))
+            }
+            ("spk_eq", 2) => {
+                let l = SpkExpr::from_tree_parent(&top.args[0], &top.name, 0)?;
+                let r = SpkExpr::from_tree_parent(&top.args[1], &top.name, 1)?;
+                Ok(CovOps::SpkEq(l, r))
+            }
             ("curr_idx_eq", 1) => {
                 expression::terminal(&top.args[0], expression::parse_num::<usize>)
                     .map(CovOps::CurrIndEq)
@@ -424,7 +434,11 @@ impl<T: ExtParam> Extension for CovOps<T> {
     fn extra_prop(&self) -> ExtData {
         ExtData {
             pk_cost: self.script_size(), // 1 opcodes, 1 key push, msg, 1 msg push
-            has_free_verify: false,
+            has_free_verify: if let CovOps::CurrIndEq(..) = self {
+                true
+            } else {
+                false
+            },
             stack_elem_count_sat: Some(0),
             stack_elem_count_dissat: Some(0),
             max_sat_size: Some((0, 0)),
@@ -1144,6 +1158,16 @@ mod tests {
         _test_parse("and_v(v:pk(K),and_v(v:value_eq(ConfVal,ConfVal),and_v(v:spk_eq(V1Spk,V1Spk),curr_idx_eq(1))))");
     }
 
+    #[test]
+    fn options_fail_test() {
+        type MsExt = Miniscript<XOnlyPublicKey, Tap, CovOps<CovExtArgs>>;
+
+        // 33 bytes explicit asset succeeds
+        MsExt::from_str_insane("asset_eq(out_asset(0),0179d51a47e4ac8e32306486dd0926a88678c392f2ed5f213e3ff2ad461c7c25e1)").unwrap();
+        // 32 bytes explicit asset without prefix fails
+        MsExt::from_str_insane("asset_eq(out_asset(0),79d51a47e4ac8e32306486dd0926a88678c392f2ed5f213e3ff2ad461c7c25e1)").unwrap_err();
+    }
+
     #[rustfmt::skip]
     fn _test_parse(s: &str) {
         type MsExtStr = Miniscript<String, Tap, CovOps<String>>;
@@ -1170,5 +1194,7 @@ mod tests {
         let ms = ms.translate_ext(&mut ext_t).unwrap();
         // script rtt
         assert_eq!(ms.encode(), MsExt::parse_insane(&ms.encode()).unwrap().encode());
+        // String rtt of the translated script
+        assert_eq!(ms, MsExt::from_str_insane(&ms.to_string()).unwrap())
     }
 }