Add header variant to Literal

Author: sethdusek

ergotree-interpreter/src/eval/sglobal.rs

@@ -223,7 +223,7 @@ pub(crate) static SGLOBAL_NONE_EVAL_FN: EvalFn = |_mc, _env, _ctx, obj, _args| {
 #[cfg(test)]
 #[cfg(feature = "arbitrary")]
 mod tests {
-    use ergo_chain_types::EcPoint;
+    use ergo_chain_types::{EcPoint, Header};
     use ergotree_ir::bigint256::BigInt256;
     use ergotree_ir::ergo_tree::ErgoTreeVersion;
     use ergotree_ir::mir::constant::Constant;
@@ -581,5 +581,9 @@ mod tests {
         fn serialize_unsigned_bigint(v in any::<UnsignedBigInt>()) {
             assert_eq!(deserialize(&serialize(v), SType::SUnsignedBigInt), Constant::from(v));
         }
+        #[test]
+        fn serialize_header(h in any::<Header>()) {
+            assert_eq!(deserialize(&serialize(h.clone()), SType::SHeader), Constant::from(h));
+        }
     }
 }

ergotree-ir/src/mir/constant.rs

@@ -31,6 +31,7 @@ use ergo_chain_types::ADDigest;
 use ergo_chain_types::Base16DecodedBytes;
 use ergo_chain_types::Digest32;
 use ergo_chain_types::EcPoint;
+use ergo_chain_types::Header;
 use impl_trait_for_tuples::impl_for_tuples;
 use sigma_util::AsVecI8;
 use sigma_util::AsVecU8;
@@ -83,6 +84,8 @@ pub enum Literal {
     GroupElement(Arc<EcPoint>),
     /// AVL tree
     AvlTree(Box<AvlTreeData>),
+    /// Block Header type
+    Header(Box<Header>),
     /// Ergo box
     CBox(Ref<'static, ErgoBox>),
     /// Collection
@@ -165,6 +168,7 @@ impl core::fmt::Debug for Literal {
             Literal::GroupElement(v) => v.fmt(f),
             Literal::UnsignedBigInt(v) => v.fmt(f),
             Literal::AvlTree(v) => v.fmt(f),
+            Literal::Header(v) => v.fmt(f),
             Literal::CBox(v) => v.fmt(f),
             Literal::String(v) => v.fmt(f),
         }
@@ -224,6 +228,7 @@ impl core::fmt::Display for Literal {
             Literal::UnsignedBigInt(v) => v.fmt(f),
             Literal::GroupElement(v) => v.fmt(f),
             Literal::AvlTree(v) => write!(f, "AvlTree({:?})", v),
+            Literal::Header(v) => write!(f, "Header({:?})", v),
             Literal::CBox(v) => write!(f, "ErgoBox({:?})", v),
             Literal::String(v) => write!(f, "String({v})"),
         }
@@ -422,9 +427,9 @@ impl<'ctx> TryFrom<Value<'ctx>> for Constant {
                 }
             }
             Value::AvlTree(a) => Ok(Constant::from(*a)),
+            Value::Header(h) => Ok(Constant::from(*h)),
             Value::String(s) => Ok(Constant::from(s)),
             Value::Context => Err("Cannot convert Value::Context into Constant".into()),
-            Value::Header(_) => Err("Cannot convert Value::Header(_) into Constant".into()),
             Value::PreHeader(_) => Err("Cannot convert Value::PreHeader(_) into Constant".into()),
             Value::Global => Err("Cannot convert Value::Global into Constant".into()),
             Value::Lambda(_) => Err("Cannot convert Value::Lambda(_) into Constant".into()),
@@ -643,6 +648,15 @@ impl From<AvlTreeData> for Constant {
     }
 }
 
+impl From<Header> for Constant {
+    fn from(h: Header) -> Self {
+        Constant {
+            tpe: SType::SHeader,
+            v: Literal::Header(h.into()),
+        }
+    }
+}
+
 impl From<AvlTreeFlags> for Constant {
     fn from(a: AvlTreeFlags) -> Self {
         Constant {
@@ -1209,6 +1223,8 @@ pub(crate) mod arbitrary {
 #[cfg(feature = "arbitrary")]
 #[allow(clippy::panic)]
 mod tests {
+    use crate::{ergo_tree::ErgoTreeVersion, serialization::roundtrip_new_feature};
+
     use super::*;
     use core::fmt;
     use proptest::prelude::*;
@@ -1424,5 +1440,10 @@ mod tests {
             test_constant_roundtrip(v);
         }
 
+        #[test]
+        fn header_ser_roundtrip(h in any::<Header>()) {
+            roundtrip_new_feature(&Constant::from(h), ErgoTreeVersion::V3);
+        }
+
     }
 }

ergotree-ir/src/mir/value.rs

@@ -386,6 +386,7 @@ impl From<Literal> for Value<'static> {
                 Value::Coll(converted_coll)
             }
             Literal::AvlTree(a) => Value::AvlTree(a),
+            Literal::Header(h) => Value::Header(h),
             Literal::Opt(lit) => Value::Opt(lit.map(|boxed| *boxed).map(Value::from).map(Box::new)),
             Literal::Tup(t) => Value::Tup(t.mapped(Value::from)),
         }

ergotree-ir/src/serialization/data.rs

@@ -1,4 +1,6 @@
 use alloc::boxed::Box;
+use ergo_chain_types::Header;
+use sigma_ser::ScorexSerializable;
 
 use alloc::string::String;
 use alloc::string::ToString;
@@ -93,13 +95,21 @@ impl DataSerializer {
             Literal::Tup(items) => items
                 .iter()
                 .try_for_each(|i| DataSerializer::sigma_serialize(i, w))?,
+            Literal::Header(h) if w.tree_version() >= ErgoTreeVersion::V3 => {
+                h.scorex_serialize(w)?;
+            }
             // unsupported, see
             // https://github.com/ScorexFoundation/sigmastate-interpreter/issues/659
             Literal::Opt(_) => {
                 return Err(SigmaSerializationError::NotSupported(
                     "Option serialization is not supported".to_string(),
                 ));
             }
+            Literal::Header(_) => {
+                return Err(SigmaSerializationError::NotSupported(
+                    "Header serialization is not supported".to_string(),
+                ));
+            }
         })
     }
 
@@ -174,6 +184,9 @@ impl DataSerializer {
             }
             SBox => Literal::CBox(Arc::new(ErgoBox::sigma_parse(r)?).into()),
             SAvlTree => Literal::AvlTree(Box::new(AvlTreeData::sigma_parse(r)?)),
+            SHeader if r.tree_version() >= ErgoTreeVersion::V3 => {
+                Literal::Header(Box::new(Header::scorex_parse(r)?))
+            }
             STypeVar(_) => return Err(SigmaParsingError::NotSupported("TypeVar data")),
             SAny => return Err(SigmaParsingError::NotSupported("SAny data")),
             SOption(_) => return Err(SigmaParsingError::NotSupported("SOption data")),