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

Author: sethdusek

bindings/ergo-lib-c-core/src/error_conversion.rs

@@ -16,6 +16,7 @@ use ergo_lib::ergotree_ir::chain::address::AddressError;
 use ergo_lib::ergotree_ir::chain::ergo_box::box_value::BoxValueError;
 use ergo_lib::ergotree_ir::chain::ergo_box::RegisterValueError;
 use ergo_lib::ergotree_ir::chain::token::TokenAmountError;
+use ergo_lib::ergotree_ir::soft_fork::SoftForkError;
 use ergo_lib::wallet::derivation_path::ChildIndexError;
 use ergo_lib::wallet::signing::TxSigningError;
 use ergo_lib::wallet::tx_context::TransactionContextError;
@@ -58,6 +59,7 @@ convert_error!(WalletError);
 convert_error!(DecodeError);
 convert_error!(TryFromSliceError);
 convert_error!(TransactionContextError);
+convert_error!(SoftForkError);
 
 macro_rules! convert_error_via_debug {
     ($t:ident) => {

bindings/ergo-lib-wasm/src/error_conversion.rs

@@ -18,6 +18,7 @@ use ergo_lib::ergotree_ir::chain::address::AddressError;
 use ergo_lib::ergotree_ir::chain::ergo_box::box_value::BoxValueError;
 use ergo_lib::ergotree_ir::chain::ergo_box::RegisterValueError;
 use ergo_lib::ergotree_ir::chain::token::TokenAmountError;
+use ergo_lib::ergotree_ir::soft_fork::SoftForkError;
 use ergo_lib::wallet::derivation_path::ChildIndexError;
 use ergo_lib::wallet::derivation_path::DerivationPathError;
 use ergo_lib::wallet::ext_pub_key::ExtPubKeyError;
@@ -99,6 +100,7 @@ from_error_to_wrap!(TransactionContextError);
 from_error_to_wrap!(TxValidationError);
 from_error_to_wrap!(RegisterValueError);
 from_error_to_wrap!(String);
+from_error_to_wrap!(SoftForkError);
 
 macro_rules! from_error_to_wrap_via_debug {
     ($t:ident) => {

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.
@@ -120,14 +122,14 @@ pub enum ErgoTree {
         /// Original tree bytes
         tree_bytes: Vec<u8>,
         /// Parsing error
-        error: ErgoTreeError,
+        error: SoftForkError,
     },
     /// Parsed tree
     Parsed(ParsedErgoTree),
 }
 
 impl ErgoTree {
-    fn parsed_tree(&self) -> Result<&ParsedErgoTree, ErgoTreeError> {
+    fn parsed_tree(&self) -> Result<&ParsedErgoTree, SoftForkError> {
         match self {
             ErgoTree::Unparsed {
                 tree_bytes: _,
@@ -138,14 +140,14 @@ impl ErgoTree {
     }
 
     /// Return ErgoTreeHeader. Errors if deserializing ergotree failed
-    pub fn header(&self) -> Result<ErgoTreeHeader, ErgoTreeError> {
+    pub fn header(&self) -> Result<ErgoTreeHeader, SoftForkError> {
         self.parsed_tree().map(|parsed| parsed.header.clone())
     }
 
     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,
@@ -273,21 +275,21 @@ impl ErgoTree {
 
     /// Returns constants number as stored in serialized ErgoTree or error if the parsing of
     /// constants is failed
-    pub fn constants_len(&self) -> Result<usize, ErgoTreeError> {
+    pub fn constants_len(&self) -> Result<usize, SoftForkError> {
         self.parsed_tree().map(|tree| tree.constants.len())
     }
 
     /// Returns constant with given index (as stored in serialized ErgoTree)
     /// or None if index is out of bounds
     /// or error if constants parsing were failed
-    pub fn get_constant(&self, index: usize) -> Result<Option<Constant>, ErgoTreeError> {
+    pub fn get_constant(&self, index: usize) -> Result<Option<Constant>, SoftForkError> {
         self.parsed_tree()
             .map(|tree| tree.constants.get(index).cloned())
     }
 
     /// Returns all constants (as stored in serialized ErgoTree)
     /// or error if constants parsing were failed
-    pub fn get_constants(&self) -> Result<Vec<Constant>, ErgoTreeError> {
+    pub fn get_constants(&self) -> Result<Vec<Constant>, SoftForkError> {
         self.parsed_tree().map(|tree| tree.constants.clone())
     }
 
@@ -390,16 +392,18 @@ 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,
+                            #[allow(clippy::unwrap_used)] // Error is checked to be soft fork condition above
+                            error: error.to_soft_fork().unwrap().clone(),
                         })
                     }
+                    Err(error) => Err(error),
                 }
             } else {
                 let constants = if header.is_constant_segregation() {
@@ -503,6 +507,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 +542,9 @@ mod tests {
         ];
         assert_eq!(
             ErgoTree::sigma_parse_bytes(&bytes),
-            Err(SigmaParsingError::InvalidTypeCode(0))
+            Err(SigmaParsingError::SoftForkError(
+                SoftForkError::InvalidPrimitiveType(0)
+            ))
         );
     }
 
@@ -696,7 +703,7 @@ mod tests {
             tree,
             ErgoTree::Unparsed {
                 tree_bytes,
-                error: ErgoTreeError::RootTpeError(SType::SByte)
+                error: SoftForkError::InvalidRootType
             }
         );
     }
@@ -725,7 +732,7 @@ mod tests {
             tree,
             ErgoTree::Unparsed {
                 tree_bytes: bytes,
-                error: ErgoTreeError::RootTpeError(SType::SShort)
+                error: SoftForkError::InvalidRootType
             }
         );
     }

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