Add SoftFork error support, only leave ErgoTree unparsed if SoftFork error is encountered

Author: sethdusek

ergotree-interpreter/src/eval/deserialize_register.rs

@@ -14,6 +14,7 @@ mod tests {
     use ergotree_ir::mir::global_vars::GlobalVars;
     use ergotree_ir::mir::value::Value;
     use ergotree_ir::serialization::SigmaSerializable;
+    use ergotree_ir::soft_fork::SoftForkError;
     use ergotree_ir::types::stype::SType;
     use sigma_test_util::force_any_val;
 
@@ -79,10 +80,9 @@ mod tests {
         assert!(matches!(
             try_eval_with_deserialize::<i32>(&expr, &ctx),
             Err(EvalError::SubstDeserializeError(
-                ergotree_ir::mir::expr::SubstDeserializeError::ExprTpeError {
-                    expected: _,
-                    actual: _
-                }
+                ergotree_ir::mir::expr::SubstDeserializeError::SoftForkError(
+                    SoftForkError::DeserializedScriptError
+                )
             ))
         ));
         // default provided
@@ -133,10 +133,9 @@ mod tests {
         assert!(matches!(
             try_eval_with_deserialize::<bool>(&expr, &ctx),
             Err(EvalError::SubstDeserializeError(
-                ergotree_ir::mir::expr::SubstDeserializeError::ExprTpeError {
-                    expected: _,
-                    actual: _
-                }
+                ergotree_ir::mir::expr::SubstDeserializeError::SoftForkError(
+                    SoftForkError::DeserializedScriptError
+                )
             ))
         ));
     }

ergotree-ir/src/ergo_tree.rs

@@ -10,6 +10,8 @@ use crate::serialization::{
     SigmaParsingError, SigmaSerializable,
 };
 use crate::sigma_protocol::sigma_boolean::ProveDlog;
+use crate::soft_fork::IsSoftForkable;
+use crate::soft_fork::SoftForkError;
 use crate::types::stype::SType;
 
 use alloc::string::String;
@@ -107,9 +109,9 @@ pub enum ErgoTreeError {
     /// IO error
     #[error("IO error: {0:?}")]
     IoError(String),
-    /// ErgoTree root error. ErgoTree root TPE should be SigmaProp
-    #[error("Root Tpe error: expected SigmaProp, got {0}")]
-    RootTpeError(SType),
+    /// Soft-fork error condition
+    #[error("Soft fork error: {0}")]
+    SoftForkError(SoftForkError),
 }
 
 /// The root of ErgoScript IR. Serialized instances of this class are self sufficient and can be passed around.
@@ -145,7 +147,7 @@ impl ErgoTree {
     fn sigma_parse_sized<R: SigmaByteRead>(
         r: &mut R,
         header: ErgoTreeHeader,
-    ) -> Result<ParsedErgoTree, ErgoTreeError> {
+    ) -> Result<ParsedErgoTree, SigmaParsingError> {
         let constants = if header.is_constant_segregation() {
             ErgoTree::sigma_parse_constants(r)?
         } else {
@@ -159,7 +161,7 @@ impl ErgoTree {
         let has_deserialize = r.was_deserialize();
         r.set_deserialize(was_deserialize);
         if root.tpe() != SType::SSigmaProp {
-            return Err(ErgoTreeError::RootTpeError(root.tpe()));
+            return Err(SoftForkError::InvalidRootType.into());
         }
         Ok(ParsedErgoTree {
             header,
@@ -390,16 +392,17 @@ impl SigmaSerializable for ErgoTree {
                     ErgoTree::sigma_parse_sized(inner_r, header)
                 }) {
                     Ok(parsed_tree) => Ok(parsed_tree.into()),
-                    Err(error) => {
+                    Err(error) if error.is_soft_fork() => {
                         let num_bytes = (body_pos - start_pos) + tree_size_bytes as u64;
                         r.seek(io::SeekFrom::Start(start_pos))?;
                         let mut bytes = vec![0; num_bytes as usize];
                         r.read_exact(&mut bytes)?;
                         Ok(ErgoTree::Unparsed {
                             tree_bytes: bytes,
-                            error,
+                            error: error.into(),
                         })
                     }
+                    Err(error) => Err(error),
                 }
             } else {
                 let constants = if header.is_constant_segregation() {
@@ -503,6 +506,7 @@ mod tests {
     use crate::mir::constant::Literal;
     use crate::mir::deserialize_context::DeserializeContext;
     use crate::sigma_protocol::sigma_boolean::SigmaProp;
+    use crate::soft_fork::SoftForkError;
     use proptest::prelude::*;
 
     proptest! {
@@ -537,7 +541,9 @@ mod tests {
         ];
         assert_eq!(
             ErgoTree::sigma_parse_bytes(&bytes),
-            Err(SigmaParsingError::InvalidTypeCode(0))
+            Err(SigmaParsingError::SoftForkError(
+                SoftForkError::InvalidPrimitiveType(0)
+            ))
         );
     }
 
@@ -696,7 +702,7 @@ mod tests {
             tree,
             ErgoTree::Unparsed {
                 tree_bytes,
-                error: ErgoTreeError::RootTpeError(SType::SByte)
+                error: ErgoTreeError::SigmaParsingError(SoftForkError::InvalidRootType.into())
             }
         );
     }
@@ -725,7 +731,7 @@ mod tests {
             tree,
             ErgoTree::Unparsed {
                 tree_bytes: bytes,
-                error: ErgoTreeError::RootTpeError(SType::SShort)
+                error: ErgoTreeError::SigmaParsingError(SoftForkError::InvalidRootType.into())
             }
         );
     }

ergotree-ir/src/lib.rs

@@ -38,6 +38,7 @@ pub mod sigma_protocol;
 pub mod source_span;
 #[macro_use]
 pub mod traversable;
+pub mod soft_fork;
 pub mod type_check;
 pub mod types;
 pub mod unsignedbigint256;

ergotree-ir/src/mir/expr.rs

@@ -17,6 +17,7 @@ use crate::serialization::sigma_byte_reader;
 use crate::serialization::sigma_byte_reader::SigmaByteRead;
 use crate::serialization::SigmaParsingError;
 use crate::serialization::SigmaSerializable;
+use crate::soft_fork::SoftForkError;
 use crate::source_span::Spanned;
 use crate::traversable::Traversable;
 use crate::types::stype::LiftIntoSType;
@@ -450,10 +451,7 @@ impl Expr {
                     _ => unreachable!(),
                 };
                 if parsed_expr.tpe() != *tpe {
-                    return Err(SubstDeserializeError::ExprTpeError {
-                        expected: tpe.clone(),
-                        actual: parsed_expr.tpe(),
-                    });
+                    return Err(SoftForkError::DeserializedScriptError.into());
                 }
                 *expr = parsed_expr;
                 Ok(())
@@ -685,8 +683,8 @@ pub enum SubstDeserializeError {
     RegisterValueError(#[from] RegisterValueError),
     #[error("Error while parsing Expr from bytes: {0}")]
     ExprParsingError(#[from] SigmaParsingError),
-    #[error("Expected tpe {expected}, found {actual}")]
-    ExprTpeError { expected: SType, actual: SType },
+    #[error("{0}")]
+    SoftForkError(#[from] SoftForkError),
 }
 
 impl<T: TryFrom<Expr>> TryExtractFrom<Expr> for T {

ergotree-ir/src/mir/sigma_prop_bytes.rs

@@ -38,7 +38,7 @@ impl OneArgOp for SigmaPropBytes {
 
 impl OneArgOpTryBuild for SigmaPropBytes {
     fn try_build(input: Expr) -> Result<Self, InvalidArgumentError> {
-        input.check_post_eval_tpe(&SType::SSigmaProp)?;
+        // dbg!(&input).check_post_eval_tpe(&SType::SSigmaProp)?;
         Ok(SigmaPropBytes {
             input: input.into(),
         })

ergotree-ir/src/serialization/data.rs

@@ -3,7 +3,6 @@ use ergo_chain_types::Header;
 use sigma_ser::ScorexSerializable;
 
 use alloc::string::String;
-use alloc::string::ToString;
 use alloc::vec;
 use alloc::vec::Vec;
 use sigma_util::AsVecU8;
@@ -17,12 +16,12 @@ use crate::mir::constant::TryExtractFromError;
 use crate::mir::constant::TryExtractInto;
 use crate::mir::value::CollKind;
 use crate::mir::value::NativeColl;
-use crate::serialization::SigmaSerializationError;
 use crate::serialization::SigmaSerializeResult;
 use crate::serialization::{
     sigma_byte_reader::SigmaByteRead, SigmaParsingError, SigmaSerializable,
 };
 use crate::sigma_protocol::{sigma_boolean::SigmaBoolean, sigma_boolean::SigmaProp};
+use crate::soft_fork::SoftForkError;
 use crate::types::stuple;
 use crate::types::stype::SType;
 use crate::unsignedbigint256::UnsignedBigInt;
@@ -59,9 +58,10 @@ impl DataSerializer {
                 v.sigma_serialize(w)?
             }
             Literal::UnsignedBigInt(_) => {
-                return Err(SigmaSerializationError::NotSupported(
-                    "Can't serialize UnsignedBigInt with tree version < 3".into(),
-                ))
+                return Err(SoftForkError::NotSerializable(
+                    "Can't serialize UnsignedBigInt with tree version < 3",
+                )
+                .into())
             }
             Literal::AvlTree(a) => a.sigma_serialize(w)?,
             Literal::CBox(b) => b.sigma_serialize(w)?,
@@ -101,14 +101,16 @@ impl DataSerializer {
             // unsupported, see
             // https://github.com/ScorexFoundation/sigmastate-interpreter/issues/659
             Literal::Opt(_) => {
-                return Err(SigmaSerializationError::NotSupported(
-                    "Option serialization is not supported".to_string(),
-                ));
+                return Err(SoftForkError::NotSerializable(
+                    "Option serialization is not supported",
+                )
+                .into());
             }
             Literal::Header(_) => {
-                return Err(SigmaSerializationError::NotSupported(
-                    "Header serialization is not supported".to_string(),
-                ));
+                return Err(SoftForkError::NotSerializable(
+                    "Header serialization is not supported",
+                )
+                .into());
             }
         })
     }
@@ -187,14 +189,14 @@ impl DataSerializer {
             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")),
-            SFunc(_) => return Err(SigmaParsingError::NotSupported("SFunc data")),
-            SContext => return Err(SigmaParsingError::NotSupported("SContext data")),
-            SHeader => return Err(SigmaParsingError::NotSupported("SHeader data")),
-            SPreHeader => return Err(SigmaParsingError::NotSupported("SPreHeader data")),
-            SGlobal => return Err(SigmaParsingError::NotSupported("SGlobal data")),
+            STypeVar(_) => return Err(SoftForkError::NotSerializable("TypeVar data").into()),
+            SAny => return Err(SoftForkError::NotSerializable("SAny data").into()),
+            SOption(_) => return Err(SoftForkError::NotSerializable("SOption data").into()),
+            SFunc(_) => return Err(SoftForkError::NotSerializable("SFunc data").into()),
+            SContext => return Err(SoftForkError::NotSerializable("SContext data").into()),
+            SHeader => return Err(SoftForkError::NotSerializable("SHeader data").into()),
+            SPreHeader => return Err(SoftForkError::NotSerializable("SPreHeader data").into()),
+            SGlobal => return Err(SoftForkError::NotSerializable("SGlobal data").into()),
         })
     }
 }

ergotree-ir/src/serialization/expr.rs

@@ -78,6 +78,7 @@ use crate::serialization::{
 };
 
 use crate::mir::xor_of::XorOf;
+use crate::soft_fork::SoftForkError;
 use crate::source_span::Spanned;
 
 impl Expr {
@@ -192,11 +193,12 @@ impl Expr {
                 XorOf::OP_CODE => Ok(XorOf::sigma_parse(r)?.into()),
                 TreeLookup::OP_CODE => Ok(TreeLookup::sigma_parse(r)?.into()),
                 CreateAvlTree::OP_CODE => Ok(CreateAvlTree::sigma_parse(r)?.into()),
-                o => Err(SigmaParsingError::NotImplementedOpCode(format!(
+                o => Err(SoftForkError::InvalidOpCode(format!(
                     "{0}(shift {1})",
                     o.value(),
                     o.shift()
-                ))),
+                ))
+                .into()),
             }
         };
         res

ergotree-ir/src/serialization/method_call.rs

@@ -4,6 +4,7 @@ use alloc::vec::Vec;
 
 use crate::mir::expr::Expr;
 use crate::mir::method_call::MethodCall;
+use crate::soft_fork::SoftForkError;
 use crate::types::smethod::MethodId;
 use crate::types::smethod::SMethod;
 use crate::types::stype::SType;
@@ -38,10 +39,7 @@ impl SigmaSerializable for MethodCall {
         let arg_types = args.iter().map(|arg| arg.tpe()).collect();
         let method = SMethod::from_ids(type_id, method_id)?.specialize_for(obj.tpe(), arg_types)?;
         if r.tree_version() < method.method_raw.min_version {
-            return Err(SigmaParsingError::UnknownMethodId(
-                method_id,
-                type_id.value(),
-            ));
+            return Err(SoftForkError::UnknownMethodId(method_id, type_id.value()).into());
         }
         let explicit_type_args = method
             .method_raw

ergotree-ir/src/serialization/serializable.rs

@@ -3,14 +3,14 @@ use crate::chain::ergo_box::RegisterValueError;
 use crate::ergo_tree::{ErgoTreeHeaderError, ErgoTreeVersion};
 use crate::mir::val_def::ValId;
 use crate::mir::{constant::TryExtractFromError, expr::InvalidArgumentError};
+use crate::soft_fork::SoftForkError;
 use crate::types::type_unify::TypeUnificationError;
 
 use super::{
     constant_store::ConstantStore,
     sigma_byte_reader::{SigmaByteRead, SigmaByteReader},
     sigma_byte_writer::{SigmaByteWrite, SigmaByteWriter},
 };
-use crate::types::smethod::MethodId;
 use alloc::boxed::Box;
 
 use alloc::string::{String, ToString};
@@ -41,6 +41,9 @@ pub enum SigmaSerializationError {
     /// Scorex serialization error
     #[error("Scorex serialization error: {0}")]
     ScorexSerializationError(#[from] ScorexSerializationError),
+    /// Soft-fork error
+    #[error("{0}")]
+    SoftForkError(#[from] SoftForkError),
 }
 
 impl From<io::Error> for SigmaSerializationError {
@@ -52,18 +55,6 @@ impl From<io::Error> for SigmaSerializationError {
 /// Ways parsing might fail
 #[derive(Error, Eq, PartialEq, Debug, Clone)]
 pub enum SigmaParsingError {
-    /// Invalid op code
-    #[error("invalid op code: {0}")]
-    InvalidOpCode(u8),
-    /// Lacking support for the op
-    #[error("not implemented op error: {0}")]
-    NotImplementedOpCode(String),
-    /// Failed to parse type
-    #[error("type parsing error, invalid type code: {0}({0:#04X})")]
-    InvalidTypeCode(u8),
-    /// V6 type error
-    #[error("Can't use v6 types (UnsignedBigInt, Header, Option) in ContextExtension/Registers ")]
-    V6TypeError,
     /// Failed to decode VLQ
     #[error("vlq encode error: {0}")]
     VlqEncode(#[from] vlq_encode::VlqEncodingError),
@@ -91,9 +82,6 @@ pub enum SigmaParsingError {
     /// Invalid argument on node creation
     #[error("Invalid argument: {0:?}")]
     InvalidArgument(#[from] InvalidArgumentError),
-    /// Unknown method ID for given type code
-    #[error("No method id {0:?} found in type companion with type id {1:?} ")]
-    UnknownMethodId(MethodId, u8),
     /// Feature not supported
     #[error("parsing not supported: {0}")]
     NotSupported(&'static str),
@@ -112,6 +100,9 @@ pub enum SigmaParsingError {
     /// Invalid register value
     #[error("Invalid register value: {0}")]
     InvalidRegisterValue(#[from] RegisterValueError),
+    /// Soft-forkable error
+    #[error("{0}")]
+    SoftForkError(#[from] SoftForkError),
 }
 
 impl From<io::Error> for SigmaParsingError {