Soft Fork support

Cargo.toml

@@ -58,7 +58,7 @@ derive_more = { version = "2.0.1", default-features = false, features = [
 ] }
 num-derive = "0.4.2"
 thiserror = { version = "2.0.1", default-features = false }
-bounded-vec = { version = "0.8.0", default-features = false }
+bounded-vec = { version = "0.9.0", default-features = false }
 bitvec = { version = "1.0.1", default-features = false, features = ["alloc"] }
 blake2 = { version = "0.10.6", default-features = false }
 sha2 = { version = "0.10", default-features = false }

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/box_selector.rs

@@ -1,4 +1,5 @@
 //! Simple box selection algorithms
+use bounded_vec::NonEmptyBoundedVec;
 use ergo_lib::ergotree_ir::chain;
 use ergo_lib::wallet;
 use ergo_lib::wallet::box_selector::BoxSelector;
@@ -9,7 +10,6 @@ use crate::ergo_box::BoxValue;
 use crate::ergo_box::ErgoBoxAssetsDataList;
 use crate::error_conversion::to_js;
 use crate::token::Tokens;
-use bounded_vec::BoundedVec;
 
 extern crate derive_more;
 use derive_more::{From, Into};
@@ -29,7 +29,7 @@ impl BoxSelection {
         Ok(BoxSelection(wallet::box_selector::BoxSelection::<
             ergo_lib::ergotree_ir::chain::ergo_box::ErgoBox,
         > {
-            boxes: BoundedVec::from_vec(boxes.clone().into()).map_err(to_js)?,
+            boxes: NonEmptyBoundedVec::from_vec(boxes.clone().into()).map_err(to_js)?,
             change_boxes: change.clone().into(),
         }))
     }

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) => {

ergo-lib/src/wallet/multi_sig.rs

@@ -16,7 +16,6 @@ use crate::ergotree_interpreter::sigma_protocol::unproven_tree::NodePosition;
 use crate::ergotree_interpreter::sigma_protocol::FirstProverMessage;
 use crate::ergotree_ir::sigma_protocol::sigma_boolean::SigmaBoolean;
 use crate::ergotree_ir::sigma_protocol::sigma_boolean::SigmaConjecture;
-use crate::ergotree_ir::sigma_protocol::sigma_boolean::SigmaConjectureItems;
 use crate::ergotree_ir::sigma_protocol::sigma_boolean::SigmaProofOfKnowledgeTree;
 use crate::wallet::signing::{make_context, TransactionContext, TxSigningError};
 use alloc::vec::Vec;
@@ -40,7 +39,7 @@ pub fn bag_for_multi_sig(
     if let SigmaBoolean::TrivialProp(_) = sigma_tree {
         return Ok(HintsBag::empty());
     }
-    let ut = compute_commitments(parse_sig_compute_challenges(sigma_tree, proof.to_owned())?);
+    let ut = compute_commitments(parse_sig_compute_challenges(sigma_tree, proof.to_owned())?)?;
     // Traversing node of sigma tree
     fn traverse_node(
         tree: UncheckedTree,
@@ -51,8 +50,7 @@ pub fn bag_for_multi_sig(
     ) -> Result<(), SigParsingError> {
         match tree {
             UncheckedTree::UncheckedConjecture(unchecked_conjecture) => {
-                let items: SigmaConjectureItems<UncheckedTree> =
-                    unchecked_conjecture.children_ust();
+                let items = unchecked_conjecture.children_ust();
                 items
                     .iter()
                     .enumerate()

ergo-lib/src/wallet/tx_builder.rs

@@ -142,9 +142,6 @@ impl<S: ErgoBoxAssets + ErgoBoxId + Clone> TxBuilder<S> {
     }
 
     fn build_tx(&self) -> Result<UnsignedTransaction, TxBuilderError> {
-        if self.box_selection.boxes.is_empty() {
-            return Err(TxBuilderError::InvalidArgs("inputs are empty".to_string()));
-        }
         if self.output_candidates.is_empty() {
             return Err(TxBuilderError::InvalidArgs("outputs are empty".to_string()));
         }

ergo-p2p/src/peer_spec.rs

@@ -1,7 +1,7 @@
 //! PeerSpec types
 use std::io;
 
-use bounded_vec::BoundedVec;
+use bounded_vec::{BoundedVec, NonEmptyBoundedVec};
 use ergo_chain_types::PeerAddr;
 use sigma_ser::vlq_encode::VlqEncodingError;
 use sigma_ser::{ScorexParsingError, ScorexSerializable, ScorexSerializeResult};
@@ -118,7 +118,7 @@ impl ScorexSerializable for PeerSpec {
                 for _ in 0..n {
                     f.push(PeerFeature::scorex_parse(r)?);
                 }
-                Some(BoundedVec::from_vec(f)?)
+                Some(NonEmptyBoundedVec::from_vec(f)?)
             }
         };
 
@@ -152,7 +152,7 @@ pub mod arbitrary {
                 option::of(vec(any::<PeerFeature>(), 1..4)),
             )
                 .prop_map(|(version, declared_addr, features)| {
-                    let feats = features.map(|f| BoundedVec::from_vec(f).unwrap());
+                    let feats = features.map(|f| NonEmptyBoundedVec::from_vec(f).unwrap());
 
                     PeerSpec::new(
                         "/Ergo-Scala-client:2.0.0(iPad; U; CPU OS 3_2_1)/AndroidBuild:0.8/",

ergotree-interpreter/src/eval/coll_exists.rs

@@ -41,16 +41,7 @@ impl Evaluable for Exists {
             ))),
         };
         let normalized_input_vals: Vec<Value> = match input_v {
-            Value::Coll(coll) => {
-                if coll.elem_tpe() != &*self.elem_tpe {
-                    return Err(EvalError::UnexpectedValue(format!(
-                        "expected Exists input element type to be {0:?}, got: {1:?}",
-                        self.elem_tpe,
-                        coll.elem_tpe()
-                    )));
-                };
-                Ok(coll.as_vec())
-            }
+            Value::Coll(coll) => Ok(coll.as_vec()),
             _ => Err(EvalError::UnexpectedValue(format!(
                 "expected Map input to be Value::Coll, got: {0:?}",
                 input_v

ergotree-interpreter/src/eval/coll_filter.rs

@@ -6,6 +6,7 @@ use ergotree_ir::mir::coll_filter::Filter;
 use ergotree_ir::mir::constant::TryExtractInto;
 use ergotree_ir::mir::value::CollKind;
 use ergotree_ir::mir::value::Value;
+use ergotree_ir::types::stype::SType;
 
 use crate::eval::env::Env;
 use crate::eval::Context;
@@ -18,6 +19,13 @@ impl Evaluable for Filter {
         env: &mut Env<'ctx>,
         ctx: &Context<'ctx>,
     ) -> Result<Value<'ctx>, EvalError> {
+        let input_elem_type = match self.input.post_eval_tpe() {
+            SType::SColl(elem_type) => Ok(elem_type.clone()),
+            _ => Err(EvalError::UnexpectedExpr(format!(
+                "Expected ForAll input to be SColl, got {0:?}",
+                self.input.tpe()
+            ))),
+        }?;
         let input_v = self.input.eval(env, ctx)?;
         let condition_v = self.condition.eval(env, ctx)?;
         let input_v_clone = input_v.clone();
@@ -45,10 +53,10 @@ impl Evaluable for Filter {
         };
         let normalized_input_vals: Vec<Value> = match input_v {
             Value::Coll(coll) => {
-                if coll.elem_tpe() != &*self.elem_tpe {
+                if coll.elem_tpe() != &*input_elem_type {
                     return Err(EvalError::UnexpectedValue(format!(
                         "expected Filter input element type to be {0:?}, got: {1:?}",
-                        self.elem_tpe,
+                        input_elem_type,
                         coll.elem_tpe()
                     )));
                 };
@@ -77,7 +85,7 @@ impl Evaluable for Filter {
             .map(|(item, _)| item)
             .collect::<Arc<_>>();
         Ok(Value::Coll(CollKind::from_collection(
-            (*self.elem_tpe).clone(),
+            (*input_elem_type).clone(),
             filtered_items,
         )?))
     }

ergotree-interpreter/src/eval/coll_forall.rs

@@ -3,6 +3,7 @@ use alloc::vec::Vec;
 use ergotree_ir::mir::coll_forall::ForAll;
 use ergotree_ir::mir::constant::TryExtractInto;
 use ergotree_ir::mir::value::Value;
+use ergotree_ir::types::stype::SType;
 
 use crate::eval::env::Env;
 use crate::eval::Context;
@@ -15,6 +16,13 @@ impl Evaluable for ForAll {
         env: &mut Env<'ctx>,
         ctx: &Context<'ctx>,
     ) -> Result<Value<'ctx>, EvalError> {
+        let input_elem_type = match self.input.post_eval_tpe() {
+            SType::SColl(elem_type) => Ok(elem_type),
+            _ => Err(EvalError::UnexpectedExpr(format!(
+                "Expected ForAll input to be SColl, got {0:?}",
+                self.input.tpe()
+            ))),
+        }?;
         let input_v = self.input.eval(env, ctx)?;
         let condition_v = self.condition.eval(env, ctx)?;
         let input_v_clone = input_v.clone();
@@ -42,10 +50,10 @@ impl Evaluable for ForAll {
         };
         let normalized_input_vals: Vec<Value> = match input_v {
             Value::Coll(coll) => {
-                if coll.elem_tpe() != &*self.elem_tpe {
+                if coll.elem_tpe() != &*input_elem_type {
                     return Err(EvalError::UnexpectedValue(format!(
                         "expected ForAll input element type to be {0:?}, got: {1:?}",
-                        self.elem_tpe,
+                        input_elem_type,
                         coll.elem_tpe()
                     )));
                 };

ergotree-interpreter/src/eval/collection.rs

@@ -24,6 +24,15 @@ impl Evaluable for Collection {
             Collection::Exprs { elem_tpe, items } => {
                 let items_v: Result<Arc<[Value]>, EvalError> =
                     items.iter().map(|i| i.eval(env, ctx)).collect();
+                if let Some(tpe) = items
+                    .iter()
+                    .map(|item| item.tpe())
+                    .find(|tpe| tpe != elem_tpe)
+                {
+                    return Err(EvalError::UnexpectedExpr(format!(
+                        "Collection: expected value of type {elem_tpe:?}, found {tpe:?}"
+                    )));
+                }
                 match elem_tpe {
                     SType::SByte => {
                         let bytes: Result<Arc<[i8]>, TryExtractFromError> = items_v?

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-interpreter/src/eval/extract_reg_as.rs

@@ -1,5 +1,3 @@
-use core::convert::TryInto;
-
 use alloc::boxed::Box;
 use ergotree_ir::chain::ergo_box::ErgoBox;
 use ergotree_ir::mir::constant::TryExtractInto;
@@ -22,24 +20,19 @@ impl Evaluable for ExtractRegisterAs {
             .input
             .eval(env, ctx)?
             .try_extract_into::<Ref<'_, ErgoBox>>()?;
-        let id = self.register_id.try_into().map_err(|e| {
-            EvalError::RegisterIdOutOfBounds(format!(
-                "register index {} is out of bounds: {:?} ",
-                self.register_id, e
-            ))
-        })?;
-        let reg_val_opt = ir_box.get_register(id).map_err(|e| {
+        let reg_val_opt = ir_box.get_register(self.register_id).map_err(|e| {
             EvalError::NotFound(format!(
-                "Error getting the register id {id} with error {e:?}"
+                "Error getting the register id {} with error {e:?}",
+                self.register_id
             ))
         })?;
         match reg_val_opt {
             Some(constant) if constant.tpe == *self.elem_tpe => {
                 Ok(Value::Opt(Some(Box::new(constant.v.into()))))
             }
             Some(constant) => Err(EvalError::UnexpectedValue(format!(
-                "Expected register {id} to be of type {}, got {}",
-                self.elem_tpe, constant.tpe
+                "Expected register {} to be of type {}, got {}",
+                self.register_id, self.elem_tpe, constant.tpe
             ))),
             None => Ok(Value::Opt(None)),
         }
@@ -56,7 +49,6 @@ mod tests {
     use ergotree_ir::mir::expr::Expr;
     use ergotree_ir::mir::global_vars::GlobalVars;
     use ergotree_ir::mir::option_get::OptionGet;
-    use ergotree_ir::mir::unary_op::OneArgOpTryBuild;
     use ergotree_ir::types::stype::SType;
     use sigma_test_util::force_any_val;
 
@@ -69,7 +61,7 @@ mod tests {
         )
         .unwrap()
         .into();
-        let option_get_expr: Expr = OptionGet::try_build(get_reg_expr).unwrap().into();
+        let option_get_expr: Expr = OptionGet::new(get_reg_expr).unwrap().into();
         let ctx = force_any_val::<Context>();
         let v = eval_out::<i64>(&option_get_expr, &ctx);
         assert_eq!(v, ctx.self_box.value.as_i64());
@@ -84,7 +76,7 @@ mod tests {
         )
         .unwrap()
         .into();
-        let option_get_expr: Expr = OptionGet::try_build(get_reg_expr).unwrap().into();
+        let option_get_expr: Expr = OptionGet::new(get_reg_expr).unwrap().into();
         let ctx = force_any_val::<Context>();
         assert!(try_eval_out::<Value>(&option_get_expr, &ctx).is_err());
     }

ergotree-interpreter/src/eval/option_get.rs

@@ -36,7 +36,6 @@ mod tests {
     use ergotree_ir::mir::expr::Expr;
     use ergotree_ir::mir::extract_reg_as::ExtractRegisterAs;
     use ergotree_ir::mir::global_vars::GlobalVars;
-    use ergotree_ir::mir::unary_op::OneArgOpTryBuild;
     use ergotree_ir::types::stype::SType;
     use sigma_test_util::force_any_val;
 
@@ -49,7 +48,7 @@ mod tests {
         )
         .unwrap()
         .into();
-        let option_get_expr: Expr = OptionGet::try_build(get_reg_expr).unwrap().into();
+        let option_get_expr: Expr = OptionGet::new(get_reg_expr).unwrap().into();
         let ctx = force_any_val::<Context>();
         let v = eval_out::<i64>(&option_get_expr, &ctx);
         assert_eq!(v, ctx.self_box.value.as_i64());

ergotree-interpreter/src/eval/scontext.rs

@@ -105,8 +105,16 @@ pub(crate) static GET_VAR_FROM_INPUT_EVAL_FN: EvalFn = |mc, _env, ctx, _obj, arg
     else {
         unreachable!()
     };
-    let input_idx = args[0].clone().try_extract_into::<i16>()? as usize;
-    let var_id = args[1].clone().try_extract_into::<i8>()? as u8;
+    let input_idx = args
+        .first()
+        .ok_or_else(|| EvalError::NotFound("getVarFromInput: missing input_idx".into()))?
+        .clone()
+        .try_extract_into::<i16>()? as usize;
+    let var_id = args
+        .get(1)
+        .ok_or_else(|| EvalError::NotFound("getVarFromInput: missing input_idx".into()))?
+        .clone()
+        .try_extract_into::<i8>()? as u8;
     Ok(
         match ctx
             .extension_provider