chore(deps): Upgrade to Triton VM v0.42.0-alpha.10

Author: jan-ferdinand

derive_tasm_object/src/lib.rs

@@ -29,7 +29,7 @@ rand = "0.8.5"
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 strum = { version = "0.26", features = ["derive"] }
-triton-vm = { version = "0.42.0-alpha.9", default-features = false }
+triton-vm = { version = "0.42.0-alpha.10", default-features = false }
 
 [dev-dependencies.cargo-husky]
 version = "1"

tasm-lib/Cargo.toml

@@ -103,10 +103,10 @@ mod tests {
             // Get input value as a u64
             let lo: u32 = stack.pop().unwrap().try_into().unwrap();
             let hi: u32 = stack.pop().unwrap().try_into().unwrap();
-            let value_u64: u64 = lo as u64 + (1 << 32) * (hi as u64);
+            let value = u64::from(lo) + (1 << 32) * u64::from(hi);
 
-            let log_2_floor = value_u64.ilog2() as u64;
-            stack.push(BFieldElement::new(log_2_floor));
+            let log_2_floor = value.ilog2();
+            stack.push(bfe!(log_2_floor));
         }
 
         fn pseudorandom_initial_state(
@@ -115,7 +115,7 @@ mod tests {
             bench_case: Option<crate::snippet_bencher::BenchmarkCase>,
         ) -> Vec<BFieldElement> {
             match bench_case {
-                Some(BenchmarkCase::CommonCase) => self.init_state(u32::MAX as u64),
+                Some(BenchmarkCase::CommonCase) => self.init_state(u64::from(u32::MAX)),
                 Some(BenchmarkCase::WorstCase) => self.init_state(u64::MAX),
                 None => {
                     let mut rng: StdRng = SeedableRng::from_seed(seed);
@@ -141,47 +141,53 @@ mod tests {
 
     #[test]
     fn lo_is_not_u32_hi_is_zero() {
-        let not_u32 = BFieldElement::new(u32::MAX as u64 + 1);
+        let not_u32 = bfe!(u64::from(u32::MAX) + 1);
         let mut init_stack = Log2FloorU64.init_stack_for_isolated_run();
-        init_stack.push(BFieldElement::new(0));
+        init_stack.push(bfe!(0));
         init_stack.push(not_u32);
 
         let init_state = InitVmState::with_stack(init_stack);
+        let expected_err =
+            InstructionError::OpStackError(OpStackError::FailedU32Conversion(not_u32));
         negative_test(
             &ShadowedClosure::new(Log2FloorU64),
             init_state,
-            &[InstructionError::FailedU32Conversion(not_u32)],
+            &[expected_err],
         );
     }
 
     #[test]
     fn hi_is_not_u32() {
-        let not_u32 = BFieldElement::new(u32::MAX as u64 + 1);
+        let not_u32 = bfe!(u64::from(u32::MAX) + 1);
         let mut init_stack = Log2FloorU64.init_stack_for_isolated_run();
         init_stack.push(not_u32);
-        init_stack.push(BFieldElement::new(16));
+        init_stack.push(bfe!(16));
 
         let init_state = InitVmState::with_stack(init_stack);
+        let expected_err =
+            InstructionError::OpStackError(OpStackError::FailedU32Conversion(not_u32));
         negative_test(
             &ShadowedClosure::new(Log2FloorU64),
             init_state,
-            &[InstructionError::FailedU32Conversion(not_u32)],
+            &[expected_err],
         );
     }
 
     #[test]
     fn hi_is_not_u32_alt() {
-        let n: u64 = rand::thread_rng().next_u32() as u64;
-        let not_u32 = BFieldElement::new(u32::MAX as u64 + 1 + n);
+        let n = u64::from(rand::thread_rng().next_u32());
+        let not_u32 = bfe!(u64::from(u32::MAX) + 1 + n);
         let mut init_stack = Log2FloorU64.init_stack_for_isolated_run();
         init_stack.push(not_u32);
-        init_stack.push(BFieldElement::new(16));
+        init_stack.push(bfe!(16));
 
         let init_state = InitVmState::with_stack(init_stack);
+        let expected_err =
+            InstructionError::OpStackError(OpStackError::FailedU32Conversion(not_u32));
         negative_test(
             &ShadowedClosure::new(Log2FloorU64),
             init_state,
-            &[InstructionError::FailedU32Conversion(not_u32)],
+            &[expected_err],
         );
     }
 

tasm-lib/src/arithmetic/u64/log_2_floor_u64.rs

@@ -1,5 +1,5 @@
-use triton_vm::instruction::LabelledInstruction;
-use triton_vm::triton_asm;
+use triton_vm::prelude::triton_asm;
+use triton_vm::prelude::LabelledInstruction;
 
 use crate::data_type::DataType;
 use crate::library::Library;
@@ -250,8 +250,10 @@ mod tests {
                 &NonDeterminism::default(),
                 None,
             );
-            let err = tvm_result.unwrap_err();
-            assert!(matches!(err, InstructionError::FailedU32Conversion(_)));
+            assert!(matches!(
+                tvm_result.unwrap_err(),
+                InstructionError::OpStackError(OpStackError::FailedU32Conversion(_))
+            ));
         }
     }
 }

tasm-lib/src/arithmetic/xfe/mod_pow_u32_generic.rs

@@ -1,5 +1,5 @@
 use itertools::Itertools;
-use triton_vm::triton_asm;
+use triton_vm::prelude::triton_asm;
 
 use crate::data_type::ArrayType;
 use crate::data_type::DataType;