Introduce TracePos type for trace positions (#273)

Many internal structures refer to trace positions; this is an important type of values. In the code, it is sometimes `u32`, sometimes `usize`. While such variables usually have "_pos" suffix, having a dedicated type does improve code with type guarantees.

air/src/execution_step/air/call/call_result_setter.rs

@@ -20,6 +20,7 @@ use crate::execution_step::Generation;
 use crate::execution_step::ValueAggregate;
 
 use air_interpreter_data::CallResult;
+use air_interpreter_data::TracePos;
 use air_interpreter_data::Value;
 use air_parser::ast::CallOutputValue;
 use air_parser::ast::Variable;
@@ -52,7 +53,7 @@ pub(crate) fn set_local_result<'i>(
 pub(crate) fn set_result_from_value<'i>(
     value: Value,
     tetraplet: RcSecurityTetraplet,
-    trace_pos: usize,
+    trace_pos: TracePos,
     output: &CallOutputValue<'i>,
     exec_ctx: &mut ExecutionCtx<'i>,
 ) -> ExecutionResult<()> {

air/src/execution_step/air/call/prev_result_handler.rs

@@ -21,6 +21,7 @@ use crate::execution_step::RcSecurityTetraplet;
 
 use air_interpreter_data::CallResult;
 use air_interpreter_data::Sender;
+use air_interpreter_data::TracePos;
 use air_interpreter_interface::CallServiceResult;
 use air_parser::ast::CallOutputValue;
 use air_trace_handler::TraceHandler;
@@ -40,7 +41,7 @@ pub(super) fn handle_prev_state<'i>(
     tetraplet: &RcSecurityTetraplet,
     output: &CallOutputValue<'i>,
     prev_result: CallResult,
-    trace_pos: usize,
+    trace_pos: TracePos,
     exec_ctx: &mut ExecutionCtx<'i>,
     trace_ctx: &mut TraceHandler,
 ) -> ExecutionResult<StateDescriptor> {

air/src/execution_step/boxed_value/iterable.rs

@@ -27,6 +27,7 @@ use super::ValueAggregate;
 use crate::execution_step::RcSecurityTetraplet;
 use crate::JValue;
 
+use air_interpreter_data::TracePos;
 use std::rc::Rc;
 
 /// This trait represent bidirectional iterator and
@@ -56,13 +57,13 @@ pub(crate) trait Iterable<'ctx> {
 /// through, i.e., it is the `iterable` in the `(fold collection iterable instruction)` statement.
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub(crate) enum IterableItem<'ctx> {
-    RefRef((&'ctx JValue, &'ctx RcSecurityTetraplet, usize)),
+    RefRef((&'ctx JValue, &'ctx RcSecurityTetraplet, TracePos)),
-    RefValue((&'ctx JValue, RcSecurityTetraplet, usize)),
+    RefValue((&'ctx JValue, RcSecurityTetraplet, TracePos)),
-    RcValue((Rc<JValue>, RcSecurityTetraplet, usize)),
+    RcValue((Rc<JValue>, RcSecurityTetraplet, TracePos)),
 }
 
 impl IterableItem<'_> {
-    pub(crate) fn pos(&self) -> usize {
+    pub(crate) fn pos(&self) -> TracePos {
         use IterableItem::*;
 
         let pos = match self {

air/src/execution_step/boxed_value/iterable/json_path_result.rs

@@ -57,7 +57,7 @@ impl<'ctx> Iterable<'ctx> for IterableLambdaResult {
         }
 
         let jvalue = &self.jvalues[self.cursor];
-        let result = IterableItem::RefRef((jvalue, &self.tetraplet, 0));
+        let result = IterableItem::RefRef((jvalue, &self.tetraplet, 0.into()));
 
         Some(result)
     }

air/src/execution_step/boxed_value/iterable/vec_json_path_result.rs

@@ -59,7 +59,7 @@ impl<'ctx> Iterable<'ctx> for IterableVecJsonPathResult {
 
         let jvalue = &self.jvalues[self.cursor];
         let tetraplet = &self.tetraplets[self.cursor];
-        let result = IterableItem::RefRef((jvalue, tetraplet, 0));
+        let result = IterableItem::RefRef((jvalue, tetraplet, 0.into()));
 
         Some(result)
     }

air/src/execution_step/boxed_value/scalar.rs

@@ -19,6 +19,7 @@ use crate::execution_step::FoldState;
 use crate::execution_step::RcSecurityTetraplet;
 use crate::JValue;
 
+use air_interpreter_data::TracePos;
 use serde::Deserialize;
 use serde::Serialize;
 
@@ -30,7 +31,7 @@ use std::rc::Rc;
 pub struct ValueAggregate {
     pub result: Rc<JValue>,
     pub tetraplet: RcSecurityTetraplet,
-    pub trace_pos: usize,
+    pub trace_pos: TracePos,
 }
 
 pub(crate) enum ScalarRef<'i> {
@@ -51,7 +52,7 @@ impl<'i> ScalarRef<'i> {
 }
 
 impl ValueAggregate {
-    pub(crate) fn new(result: Rc<JValue>, tetraplet: RcSecurityTetraplet, trace_pos: usize) -> Self {
+    pub(crate) fn new(result: Rc<JValue>, tetraplet: RcSecurityTetraplet, trace_pos: TracePos) -> Self {
         Self {
             result,
             tetraplet,

air/src/execution_step/boxed_value/stream.rs

@@ -243,8 +243,8 @@ mod test {
 
     #[test]
     fn test_slice_iter() {
-        let value_1 = ValueAggregate::new(Rc::new(json!("value")), <_>::default(), 1);
+        let value_1 = ValueAggregate::new(Rc::new(json!("value")), <_>::default(), 1.into());
-        let value_2 = ValueAggregate::new(Rc::new(json!("value")), <_>::default(), 1);
+        let value_2 = ValueAggregate::new(Rc::new(json!("value")), <_>::default(), 1.into());
         let mut stream = Stream::from_generations_count(2);
 
         stream.add_value(value_1, Generation::Nth(0)).unwrap();

air/src/execution_step/execution_context/scalar_variables.rs

@@ -386,7 +386,7 @@ mod test {
         let rc_tetraplet = Rc::new(tetraplet);
         let value = json!(1u64);
         let rc_value = Rc::new(value);
-        let value_aggregate = ValueAggregate::new(rc_value, rc_tetraplet, 1);
+        let value_aggregate = ValueAggregate::new(rc_value, rc_tetraplet, 1.into());
         let value_1_name = "name_1";
         scalars.set_value(value_1_name, value_aggregate.clone()).unwrap();
 

air/tests/test_module/features/data_merging/data_merge.rs

@@ -300,7 +300,7 @@ fn fold_merge() {
 
         if let ExecutedState::Fold(fold) = state {
             for subtrace_lore in fold.lore.iter() {
-                let value_pos = subtrace_lore.value_pos as usize;
+                let value_pos = subtrace_lore.value_pos;
                 if let ExecutedState::Call(CallResult::Executed(value)) = &data.trace[value_pos] {
                     let value = match value {
                         Value::Scalar(value) => value,

air/tests/test_module/features/errors/last_error.rs

@@ -211,7 +211,7 @@ fn variable_names_shown_in_error() {
     let trace = trace_from_result(&result);
 
     assert_eq!(
-        trace[1],
+        trace[1.into()],
         executed_state::scalar(json!(
             "expected JValue type 'string' for the variable `-relay-`, but got '1'"
         ))

air/tests/test_module/features/lambda/lambda.rs

@@ -71,7 +71,7 @@ fn lambda_with_string_scalar() {
     let result = checked_call_vm!(local_vm, <_>::default(), script, "", result.data);
     let trace = trace_from_result(&result);
 
-    assert_eq!(&trace[2], &executed_state::scalar_number(1u32));
+    assert_eq!(&trace[2.into()], &executed_state::scalar_number(1u32));
 }
 
 #[test]
@@ -103,7 +103,7 @@ fn lambda_with_number_scalar() {
     let result = checked_call_vm!(local_vm, <_>::default(), script, "", result.data);
     let trace = trace_from_result(&result);
 
-    assert_eq!(&trace[2], &executed_state::scalar_number(1u32));
+    assert_eq!(&trace[2.into()], &executed_state::scalar_number(1u32));
 }
 
 #[test]
@@ -143,7 +143,7 @@ fn lambda_with_number_stream() {
     let result = checked_call_vm!(local_vm, <_>::default(), script, "", result.data);
     let actual_trace = trace_from_result(&result);
 
-    assert_eq!(&actual_trace[5], &executed_state::scalar_number(2));
+    assert_eq!(&actual_trace[5.into()], &executed_state::scalar_number(2));
 }
 
 #[test]
@@ -188,7 +188,7 @@ fn lambda_with_number_stream_and_followed_scalar() {
     let result = checked_call_vm!(local_vm, <_>::default(), script, "", result.data);
     let actual_trace = trace_from_result(&result);
 
-    assert_eq!(&actual_trace[6], &executed_state::scalar_number(checkable_value));
+    assert_eq!(&actual_trace[6.into()], &executed_state::scalar_number(checkable_value));
 }
 
 #[test]
@@ -220,7 +220,7 @@ fn lambda_with_scalar_join() {
     let result = checked_call_vm!(local_vm, <_>::default(), script, "", result.data);
     let trace = trace_from_result(&result);
 
-    assert_eq!(&trace[3], &executed_state::request_sent_by("set_variable"));
+    assert_eq!(&trace[3.into()], &executed_state::request_sent_by("set_variable"));
 }
 
 #[test]
@@ -260,5 +260,8 @@ fn lambda_with_stream_join() {
     let result = checked_call_vm!(local_vm, <_>::default(), script, "", result.data);
     let actual_trace = trace_from_result(&result);
 
-    assert_eq!(&actual_trace[6], &executed_state::request_sent_by("set_variable"));
+    assert_eq!(
+        &actual_trace[6.into()],
+        &executed_state::request_sent_by("set_variable")
+    );
 }

air/tests/test_module/features/streams/recursive_streams.rs

@@ -58,8 +58,8 @@ fn recursive_stream_with_early_exit() {
         executed_state::stream_number(1, 0),
         executed_state::stream_number(1, 1),
         executed_state::fold(vec![
-            executed_state::subtrace_lore(0, SubTraceDesc::new(3, 1), SubTraceDesc::new(4, 0)),
+            executed_state::subtrace_lore(0, subtrace_desc(3, 1), subtrace_desc(4, 0)),
-            executed_state::subtrace_lore(1, SubTraceDesc::new(4, 1), SubTraceDesc::new(5, 0)),
+            executed_state::subtrace_lore(1, subtrace_desc(4, 1), subtrace_desc(5, 0)),
         ]),
         executed_state::scalar_string("stop"),
         executed_state::scalar_string("stop"),
@@ -120,27 +120,27 @@ fn recursive_stream_many_iterations() {
 
     let result = checked_call_vm!(vm_1, <_>::default(), &script, "", "");
     let actual_trace = trace_from_result(&result);
-    let actual_fold = &actual_trace[2];
+    let actual_fold = &actual_trace[2.into()];
     let expected_fold = executed_state::fold(vec![
-        executed_state::subtrace_lore(0, SubTraceDesc::new(3, 2), SubTraceDesc::new(5, 0)),
+        executed_state::subtrace_lore(0, subtrace_desc(3, 2), subtrace_desc(5, 0)),
-        executed_state::subtrace_lore(1, SubTraceDesc::new(5, 2), SubTraceDesc::new(7, 0)),
+        executed_state::subtrace_lore(1, subtrace_desc(5, 2), subtrace_desc(7, 0)),
-        executed_state::subtrace_lore(4, SubTraceDesc::new(7, 2), SubTraceDesc::new(9, 0)),
+        executed_state::subtrace_lore(4, subtrace_desc(7, 2), subtrace_desc(9, 0)),
-        executed_state::subtrace_lore(6, SubTraceDesc::new(9, 2), SubTraceDesc::new(11, 0)),
+        executed_state::subtrace_lore(6, subtrace_desc(9, 2), subtrace_desc(11, 0)),
-        executed_state::subtrace_lore(8, SubTraceDesc::new(11, 2), SubTraceDesc::new(15, 0)),
+        executed_state::subtrace_lore(8, subtrace_desc(11, 2), subtrace_desc(15, 0)),
-        executed_state::subtrace_lore(10, SubTraceDesc::new(13, 2), SubTraceDesc::new(15, 0)),
+        executed_state::subtrace_lore(10, subtrace_desc(13, 2), subtrace_desc(15, 0)),
-        executed_state::subtrace_lore(12, SubTraceDesc::new(15, 2), SubTraceDesc::new(19, 0)),
+        executed_state::subtrace_lore(12, subtrace_desc(15, 2), subtrace_desc(19, 0)),
-        executed_state::subtrace_lore(14, SubTraceDesc::new(17, 2), SubTraceDesc::new(19, 0)),
+        executed_state::subtrace_lore(14, subtrace_desc(17, 2), subtrace_desc(19, 0)),
-        executed_state::subtrace_lore(16, SubTraceDesc::new(19, 1), SubTraceDesc::new(20, 0)),
+        executed_state::subtrace_lore(16, subtrace_desc(19, 1), subtrace_desc(20, 0)),
     ]);
     assert_eq!(actual_fold, &expected_fold);
 
-    let actual_last_state = &actual_trace[20];
+    let actual_last_state = &actual_trace[20.into()];
     let expected_last_state = executed_state::request_sent_by(vm_peer_id_1);
     assert_eq!(actual_last_state, &expected_last_state);
 
     let result = checked_call_vm!(vm_2, <_>::default(), script, "", result.data);
     let actual_trace = trace_from_result(&result);
-    let actual_last_state = &actual_trace[20];
+    let actual_last_state = &actual_trace[20.into()];
     let expected_last_state = executed_state::scalar_string(result_value);
     assert_eq!(actual_last_state, &expected_last_state);
 }
@@ -206,11 +206,11 @@ fn recursive_stream_join() {
         executed_state::stream_string("non_join", 0),
         executed_state::scalar_string(""),
         executed_state::fold(vec![
-            executed_state::subtrace_lore(1, SubTraceDesc::new(4, 2), SubTraceDesc::new(6, 0)),
+            executed_state::subtrace_lore(1, subtrace_desc(4, 2), subtrace_desc(6, 0)),
-            executed_state::subtrace_lore(5, SubTraceDesc::new(6, 2), SubTraceDesc::new(8, 0)),
+            executed_state::subtrace_lore(5, subtrace_desc(6, 2), subtrace_desc(8, 0)),
-            executed_state::subtrace_lore(7, SubTraceDesc::new(8, 2), SubTraceDesc::new(10, 0)),
+            executed_state::subtrace_lore(7, subtrace_desc(8, 2), subtrace_desc(10, 0)),
-            executed_state::subtrace_lore(9, SubTraceDesc::new(10, 2), SubTraceDesc::new(12, 0)),
+            executed_state::subtrace_lore(9, subtrace_desc(10, 2), subtrace_desc(12, 0)),
-            executed_state::subtrace_lore(11, SubTraceDesc::new(12, 2), SubTraceDesc::new(14, 0)),
+            executed_state::subtrace_lore(11, subtrace_desc(12, 2), subtrace_desc(14, 0)),
         ]),
         executed_state::scalar_string("non_join"),
         executed_state::ap(Some(1)),
@@ -280,7 +280,7 @@ fn recursive_stream_error_handling() {
     let result = checked_call_vm!(vm_1, <_>::default(), &script, "", "");
     let result = checked_call_vm!(vm_2, <_>::default(), &script, "", result.data);
     let actual_trace = trace_from_result(&result);
-    let actual_last_state = &actual_trace[10];
+    let actual_last_state = &actual_trace[10.into()];
     let expected_last_state = executed_state::scalar_string(result_value);
 
     assert_eq!(actual_last_state, &expected_last_state);
@@ -356,12 +356,12 @@ fn recursive_stream_inner_fold() {
     let result = checked_call_vm!(vm_2, <_>::default(), script, "", result.data);
     let actual_trace = trace_from_result(&result);
 
-    let actual_last_state = &actual_trace[22];
+    let actual_last_state = &actual_trace[22.into()];
     let expected_last_state = executed_state::scalar_string(result_value);
     assert_eq!(actual_last_state, &expected_last_state);
 
-    let external_fold = &actual_trace[2];
+    let external_fold = &actual_trace[2.into()];
-    let internal_fold = &actual_trace[5];
+    let internal_fold = &actual_trace[5.into()];
     let actual_fold_lores_count = match (external_fold, internal_fold) {
         (ExecutedState::Fold(external_fold), ExecutedState::Fold(internal_fold)) => {
             external_fold.lore.len() + internal_fold.lore.len()
@@ -438,7 +438,7 @@ fn recursive_stream_fold_with_n_service_call() {
     let test_params = TestRunParameters::from_init_peer_id(vm_peer_id);
     let result = checked_call_vm!(vm, test_params, &script, "", "");
     let actual_trace = trace_from_result(&result);
-    let actual_fold_state = match &actual_trace[2] {
+    let actual_fold_state = match &actual_trace[2.into()] {
         ExecutedState::Fold(fold_result) => fold_result,
         _ => panic!("2nd state should be fold"),
     };

air/tests/test_module/features/streams/streams.rs

@@ -85,9 +85,9 @@ fn stream_merging_v0() {
         executed_state::stream_string("1", 0),
         executed_state::request_sent_by(initiator_id),
         executed_state::fold(vec![
-            executed_state::subtrace_lore(7, SubTraceDesc::new(15, 2), SubTraceDesc::new(21, 0)),
+            executed_state::subtrace_lore(7, subtrace_desc(15, 2), subtrace_desc(21, 0)),
-            executed_state::subtrace_lore(9, SubTraceDesc::new(17, 2), SubTraceDesc::new(21, 0)),
+            executed_state::subtrace_lore(9, subtrace_desc(17, 2), subtrace_desc(21, 0)),
-            executed_state::subtrace_lore(12, SubTraceDesc::new(19, 2), SubTraceDesc::new(21, 0)),
+            executed_state::subtrace_lore(12, subtrace_desc(19, 2), subtrace_desc(21, 0)),
         ]),
         executed_state::scalar_string(unit_call_service_result),
         executed_state::scalar_string(unit_call_service_result),
@@ -123,11 +123,11 @@ fn stream_merging_v0() {
         executed_state::stream_string("1", 0),
         executed_state::stream_string("2", 1),
         executed_state::fold(vec![
-            executed_state::subtrace_lore(7, SubTraceDesc::new(15, 2), SubTraceDesc::new(21, 0)),
+            executed_state::subtrace_lore(7, subtrace_desc(15, 2), subtrace_desc(21, 0)),
-            executed_state::subtrace_lore(9, SubTraceDesc::new(17, 2), SubTraceDesc::new(21, 0)),
+            executed_state::subtrace_lore(9, subtrace_desc(17, 2), subtrace_desc(21, 0)),
-            executed_state::subtrace_lore(12, SubTraceDesc::new(19, 2), SubTraceDesc::new(21, 0)),
+            executed_state::subtrace_lore(12, subtrace_desc(19, 2), subtrace_desc(21, 0)),
-            executed_state::subtrace_lore(8, SubTraceDesc::new(21, 2), SubTraceDesc::new(25, 0)),
+            executed_state::subtrace_lore(8, subtrace_desc(21, 2), subtrace_desc(25, 0)),
-            executed_state::subtrace_lore(13, SubTraceDesc::new(23, 2), SubTraceDesc::new(25, 0)),
+            executed_state::subtrace_lore(13, subtrace_desc(23, 2), subtrace_desc(25, 0)),
         ]),
         executed_state::scalar_string(unit_call_service_result),
         executed_state::scalar_string(unit_call_service_result),
@@ -167,13 +167,13 @@ fn stream_merging_v0() {
         executed_state::stream_string("1", 0),
         executed_state::stream_string("2", 1),
         executed_state::fold(vec![
-            executed_state::subtrace_lore(7, SubTraceDesc::new(15, 2), SubTraceDesc::new(21, 0)),
+            executed_state::subtrace_lore(7, subtrace_desc(15, 2), subtrace_desc(21, 0)),
-            executed_state::subtrace_lore(9, SubTraceDesc::new(17, 2), SubTraceDesc::new(21, 0)),
+            executed_state::subtrace_lore(9, subtrace_desc(17, 2), subtrace_desc(21, 0)),
-            executed_state::subtrace_lore(12, SubTraceDesc::new(19, 2), SubTraceDesc::new(21, 0)),
+            executed_state::subtrace_lore(12, subtrace_desc(19, 2), subtrace_desc(21, 0)),
-            executed_state::subtrace_lore(8, SubTraceDesc::new(21, 2), SubTraceDesc::new(25, 0)),
+            executed_state::subtrace_lore(8, subtrace_desc(21, 2), subtrace_desc(25, 0)),
-            executed_state::subtrace_lore(13, SubTraceDesc::new(23, 2), SubTraceDesc::new(25, 0)),
+            executed_state::subtrace_lore(13, subtrace_desc(23, 2), subtrace_desc(25, 0)),
-            executed_state::subtrace_lore(10, SubTraceDesc::new(25, 2), SubTraceDesc::new(29, 0)),
+            executed_state::subtrace_lore(10, subtrace_desc(25, 2), subtrace_desc(29, 0)),
-            executed_state::subtrace_lore(11, SubTraceDesc::new(27, 2), SubTraceDesc::new(29, 0)),
+            executed_state::subtrace_lore(11, subtrace_desc(27, 2), subtrace_desc(29, 0)),
         ]),
         executed_state::scalar_string(unit_call_service_result),
         executed_state::scalar_string(unit_call_service_result),
@@ -237,9 +237,9 @@ fn stream_merging_v1() {
         executed_state::stream_string("1", 0),
         executed_state::request_sent_by(initiator_id),
         executed_state::fold(vec![
-            executed_state::subtrace_lore(7, SubTraceDesc::new(15, 1), SubTraceDesc::new(20, 1)),
+            executed_state::subtrace_lore(7, subtrace_desc(15, 1), subtrace_desc(20, 1)),
-            executed_state::subtrace_lore(9, SubTraceDesc::new(16, 1), SubTraceDesc::new(19, 1)),
+            executed_state::subtrace_lore(9, subtrace_desc(16, 1), subtrace_desc(19, 1)),
-            executed_state::subtrace_lore(12, SubTraceDesc::new(17, 1), SubTraceDesc::new(18, 1)),
+            executed_state::subtrace_lore(12, subtrace_desc(17, 1), subtrace_desc(18, 1)),
         ]),
         executed_state::scalar_string(unit_call_service_result),
         executed_state::scalar_string(unit_call_service_result),
@@ -275,11 +275,11 @@ fn stream_merging_v1() {
         executed_state::stream_string("1", 0),
         executed_state::stream_string("2", 1),
         executed_state::fold(vec![
-            executed_state::subtrace_lore(7, SubTraceDesc::new(15, 1), SubTraceDesc::new(20, 1)),
+            executed_state::subtrace_lore(7, subtrace_desc(15, 1), subtrace_desc(20, 1)),
-            executed_state::subtrace_lore(9, SubTraceDesc::new(16, 1), SubTraceDesc::new(19, 1)),
+            executed_state::subtrace_lore(9, subtrace_desc(16, 1), subtrace_desc(19, 1)),
-            executed_state::subtrace_lore(12, SubTraceDesc::new(17, 1), SubTraceDesc::new(18, 1)),
+            executed_state::subtrace_lore(12, subtrace_desc(17, 1), subtrace_desc(18, 1)),
-            executed_state::subtrace_lore(8, SubTraceDesc::new(21, 1), SubTraceDesc::new(24, 1)),
+            executed_state::subtrace_lore(8, subtrace_desc(21, 1), subtrace_desc(24, 1)),
-            executed_state::subtrace_lore(13, SubTraceDesc::new(22, 1), SubTraceDesc::new(23, 1)),
+            executed_state::subtrace_lore(13, subtrace_desc(22, 1), subtrace_desc(23, 1)),
         ]),
         executed_state::scalar_string(unit_call_service_result),
         executed_state::scalar_string(unit_call_service_result),
@@ -319,13 +319,13 @@ fn stream_merging_v1() {
         executed_state::stream_string("1", 0),
         executed_state::stream_string("2", 1),
         executed_state::fold(vec![
-            executed_state::subtrace_lore(7, SubTraceDesc::new(15, 1), SubTraceDesc::new(20, 1)),
+            executed_state::subtrace_lore(7, subtrace_desc(15, 1), subtrace_desc(20, 1)),
-            executed_state::subtrace_lore(9, SubTraceDesc::new(16, 1), SubTraceDesc::new(19, 1)),
+            executed_state::subtrace_lore(9, subtrace_desc(16, 1), subtrace_desc(19, 1)),
-            executed_state::subtrace_lore(12, SubTraceDesc::new(17, 1), SubTraceDesc::new(18, 1)),
+            executed_state::subtrace_lore(12, subtrace_desc(17, 1), subtrace_desc(18, 1)),
-            executed_state::subtrace_lore(8, SubTraceDesc::new(21, 1), SubTraceDesc::new(24, 1)),
+            executed_state::subtrace_lore(8, subtrace_desc(21, 1), subtrace_desc(24, 1)),
-            executed_state::subtrace_lore(13, SubTraceDesc::new(22, 1), SubTraceDesc::new(23, 1)),
+            executed_state::subtrace_lore(13, subtrace_desc(22, 1), subtrace_desc(23, 1)),
-            executed_state::subtrace_lore(10, SubTraceDesc::new(25, 1), SubTraceDesc::new(28, 1)),
+            executed_state::subtrace_lore(10, subtrace_desc(25, 1), subtrace_desc(28, 1)),
-            executed_state::subtrace_lore(11, SubTraceDesc::new(26, 1), SubTraceDesc::new(27, 1)),
+            executed_state::subtrace_lore(11, subtrace_desc(26, 1), subtrace_desc(27, 1)),
         ]),
         executed_state::scalar_string(unit_call_service_result),
         executed_state::scalar_string(unit_call_service_result),
@@ -389,9 +389,9 @@ fn stream_merging_v2() {
         executed_state::stream_string("1", 0),
         executed_state::request_sent_by(initiator_id),
         executed_state::fold(vec![
-            executed_state::subtrace_lore(7, SubTraceDesc::new(15, 0), SubTraceDesc::new(19, 2)),
+            executed_state::subtrace_lore(7, subtrace_desc(15, 0), subtrace_desc(19, 2)),
-            executed_state::subtrace_lore(9, SubTraceDesc::new(15, 0), SubTraceDesc::new(17, 2)),
+            executed_state::subtrace_lore(9, subtrace_desc(15, 0), subtrace_desc(17, 2)),
-            executed_state::subtrace_lore(12, SubTraceDesc::new(15, 0), SubTraceDesc::new(15, 2)),
+            executed_state::subtrace_lore(12, subtrace_desc(15, 0), subtrace_desc(15, 2)),
         ]),
         executed_state::scalar_string(unit_call_service_result),
         executed_state::scalar_string(unit_call_service_result),
@@ -427,11 +427,11 @@ fn stream_merging_v2() {
         executed_state::stream_string("1", 0),
         executed_state::stream_string("2", 1),
         executed_state::fold(vec![
-            executed_state::subtrace_lore(7, SubTraceDesc::new(15, 0), SubTraceDesc::new(19, 2)),
+            executed_state::subtrace_lore(7, subtrace_desc(15, 0), subtrace_desc(19, 2)),
-            executed_state::subtrace_lore(9, SubTraceDesc::new(15, 0), SubTraceDesc::new(17, 2)),
+            executed_state::subtrace_lore(9, subtrace_desc(15, 0), subtrace_desc(17, 2)),
-            executed_state::subtrace_lore(12, SubTraceDesc::new(15, 0), SubTraceDesc::new(15, 2)),
+            executed_state::subtrace_lore(12, subtrace_desc(15, 0), subtrace_desc(15, 2)),
-            executed_state::subtrace_lore(8, SubTraceDesc::new(21, 0), SubTraceDesc::new(23, 2)),
+            executed_state::subtrace_lore(8, subtrace_desc(21, 0), subtrace_desc(23, 2)),
-            executed_state::subtrace_lore(13, SubTraceDesc::new(21, 0), SubTraceDesc::new(21, 2)),
+            executed_state::subtrace_lore(13, subtrace_desc(21, 0), subtrace_desc(21, 2)),
         ]),
         executed_state::scalar_string(unit_call_service_result),
         executed_state::scalar_string(unit_call_service_result),
@@ -471,13 +471,13 @@ fn stream_merging_v2() {
         executed_state::stream_string("1", 0),
         executed_state::stream_string("2", 1),
         executed_state::fold(vec![
-            executed_state::subtrace_lore(7, SubTraceDesc::new(15, 0), SubTraceDesc::new(19, 2)),
+            executed_state::subtrace_lore(7, subtrace_desc(15, 0), subtrace_desc(19, 2)),
-            executed_state::subtrace_lore(9, SubTraceDesc::new(15, 0), SubTraceDesc::new(17, 2)),
+            executed_state::subtrace_lore(9, subtrace_desc(15, 0), subtrace_desc(17, 2)),
-            executed_state::subtrace_lore(12, SubTraceDesc::new(15, 0), SubTraceDesc::new(15, 2)),
+            executed_state::subtrace_lore(12, subtrace_desc(15, 0), subtrace_desc(15, 2)),
-            executed_state::subtrace_lore(8, SubTraceDesc::new(21, 0), SubTraceDesc::new(23, 2)),
+            executed_state::subtrace_lore(8, subtrace_desc(21, 0), subtrace_desc(23, 2)),
-            executed_state::subtrace_lore(13, SubTraceDesc::new(21, 0), SubTraceDesc::new(21, 2)),
+            executed_state::subtrace_lore(13, subtrace_desc(21, 0), subtrace_desc(21, 2)),
-            executed_state::subtrace_lore(10, SubTraceDesc::new(25, 0), SubTraceDesc::new(27, 2)),
+            executed_state::subtrace_lore(10, subtrace_desc(25, 0), subtrace_desc(27, 2)),
-            executed_state::subtrace_lore(11, SubTraceDesc::new(25, 0), SubTraceDesc::new(25, 2)),
+            executed_state::subtrace_lore(11, subtrace_desc(25, 0), subtrace_desc(25, 2)),
         ]),
         executed_state::scalar_string(unit_call_service_result),
         executed_state::scalar_string(unit_call_service_result),

air/tests/test_module/features/streams/streams_early_exit.rs

@@ -244,27 +244,27 @@ fn fold_early_exit() {
         executed_state::par(11, 1),
         executed_state::fold(vec![executed_state::subtrace_lore(
             4,
-            SubTraceDesc::new(14, 9),
+            subtrace_desc(14, 9),
-            SubTraceDesc::new(23, 0),
+            subtrace_desc(23, 0),
         )]),
         executed_state::fold(vec![executed_state::subtrace_lore(
             6,
-            SubTraceDesc::new(15, 8),
+            subtrace_desc(15, 8),
-            SubTraceDesc::new(23, 0),
+            subtrace_desc(23, 0),
         )]),
         executed_state::fold(vec![
-            executed_state::subtrace_lore(8, SubTraceDesc::new(16, 3), SubTraceDesc::new(22, 0)),
+            executed_state::subtrace_lore(8, subtrace_desc(16, 3), subtrace_desc(22, 0)),
-            executed_state::subtrace_lore(9, SubTraceDesc::new(19, 3), SubTraceDesc::new(22, 0)),
+            executed_state::subtrace_lore(9, subtrace_desc(19, 3), subtrace_desc(22, 0)),
         ]),
         executed_state::fold(vec![
-            executed_state::subtrace_lore(10, SubTraceDesc::new(17, 1), SubTraceDesc::new(19, 0)),
+            executed_state::subtrace_lore(10, subtrace_desc(17, 1), subtrace_desc(19, 0)),
-            executed_state::subtrace_lore(11, SubTraceDesc::new(18, 1), SubTraceDesc::new(19, 0)),
+            executed_state::subtrace_lore(11, subtrace_desc(18, 1), subtrace_desc(19, 0)),
         ]),
         executed_state::scalar_string(unit_call_service_result),
         executed_state::scalar_string(unit_call_service_result),
         executed_state::fold(vec![
-            executed_state::subtrace_lore(10, SubTraceDesc::new(20, 1), SubTraceDesc::new(22, 0)),
+            executed_state::subtrace_lore(10, subtrace_desc(20, 1), subtrace_desc(22, 0)),
-            executed_state::subtrace_lore(11, SubTraceDesc::new(21, 1), SubTraceDesc::new(22, 0)),
+            executed_state::subtrace_lore(11, subtrace_desc(21, 1), subtrace_desc(22, 0)),
         ]),
         executed_state::scalar_string(unit_call_service_result),
         executed_state::scalar_string(unit_call_service_result),
@@ -353,24 +353,24 @@ fn fold_par_early_exit() {
         executed_state::stream_string("d2", 0),
         executed_state::par(69, 1),
         executed_state::fold(vec![
-            executed_state::subtrace_lore(4, SubTraceDesc::new(14, 34), SubTraceDesc::new(82, 0)),
+            executed_state::subtrace_lore(4, subtrace_desc(14, 34), subtrace_desc(82, 0)),
-            executed_state::subtrace_lore(5, SubTraceDesc::new(48, 34), SubTraceDesc::new(82, 0)),
+            executed_state::subtrace_lore(5, subtrace_desc(48, 34), subtrace_desc(82, 0)),
         ]),
         executed_state::par(33, 34),
         executed_state::fold(vec![
-            executed_state::subtrace_lore(6, SubTraceDesc::new(16, 16), SubTraceDesc::new(48, 0)),
+            executed_state::subtrace_lore(6, subtrace_desc(16, 16), subtrace_desc(48, 0)),
-            executed_state::subtrace_lore(7, SubTraceDesc::new(32, 16), SubTraceDesc::new(48, 0)),
+            executed_state::subtrace_lore(7, subtrace_desc(32, 16), subtrace_desc(48, 0)),
         ]),
         executed_state::par(15, 16),
         executed_state::par(13, 1),
         executed_state::fold(vec![
-            executed_state::subtrace_lore(8, SubTraceDesc::new(19, 6), SubTraceDesc::new(31, 0)),
+            executed_state::subtrace_lore(8, subtrace_desc(19, 6), subtrace_desc(31, 0)),
-            executed_state::subtrace_lore(9, SubTraceDesc::new(25, 6), SubTraceDesc::new(31, 0)),
+            executed_state::subtrace_lore(9, subtrace_desc(25, 6), subtrace_desc(31, 0)),
         ]),
         executed_state::par(5, 6),
         executed_state::fold(vec![
-            executed_state::subtrace_lore(10, SubTraceDesc::new(21, 2), SubTraceDesc::new(25, 0)),
+            executed_state::subtrace_lore(10, subtrace_desc(21, 2), subtrace_desc(25, 0)),
-            executed_state::subtrace_lore(11, SubTraceDesc::new(23, 2), SubTraceDesc::new(25, 0)),
+            executed_state::subtrace_lore(11, subtrace_desc(23, 2), subtrace_desc(25, 0)),
         ]),
         executed_state::par(1, 2),
         executed_state::scalar_string(unit_call_service_result),
@@ -378,8 +378,8 @@ fn fold_par_early_exit() {
         executed_state::scalar_string(unit_call_service_result),
         executed_state::par(5, 0),
         executed_state::fold(vec![
-            executed_state::subtrace_lore(10, SubTraceDesc::new(27, 2), SubTraceDesc::new(31, 0)),
+            executed_state::subtrace_lore(10, subtrace_desc(27, 2), subtrace_desc(31, 0)),
-            executed_state::subtrace_lore(11, SubTraceDesc::new(29, 2), SubTraceDesc::new(31, 0)),
+            executed_state::subtrace_lore(11, subtrace_desc(29, 2), subtrace_desc(31, 0)),
         ]),
         executed_state::par(1, 2),
         executed_state::scalar_string(unit_call_service_result),
@@ -389,11 +389,11 @@ fn fold_par_early_exit() {
         executed_state::par(15, 0),
         executed_state::par(13, 1),
         executed_state::fold(vec![
-            executed_state::subtrace_lore(8, SubTraceDesc::new(35, 6), SubTraceDesc::new(47, 0)),
+            executed_state::subtrace_lore(8, subtrace_desc(35, 6), subtrace_desc(47, 0)),
-            executed_state::subtrace_lore(9, SubTraceDesc::new(41, 6), SubTraceDesc::new(47, 0)),
+            executed_state::subtrace_lore(9, subtrace_desc(41, 6), subtrace_desc(47, 0)),
         ]),
     ];
     let trace_len = expected_trace.len();
 
-    assert_eq!(&actual_trace[0..trace_len], expected_trace);
+    assert_eq!((*actual_trace)[0..trace_len], expected_trace);
 }

air/tests/test_module/features/tetraplets/security_tetraplets.rs

@@ -286,5 +286,5 @@ fn tetraplet_with_wasm_modules() {
     let actual_trace = trace_from_result(&result);
     let expected_state = executed_state::scalar_string("Ok");
 
-    assert_eq!(actual_trace[1], expected_state)
+    assert_eq!(actual_trace[1.into()], expected_state)
 }

air/tests/test_module/instructions/call.rs

@@ -97,7 +97,7 @@ fn remote_peer_id_call() {
     let expected_state = executed_state::request_sent_by(some_local_peer_id);
 
     assert_eq!(actual_trace.len(), 1);
-    assert_eq!(actual_trace[0], expected_state);
+    assert_eq!(actual_trace[0.into()], expected_state);
     assert_eq!(result.next_peer_pks, vec![remote_peer_id]);
 }
 
@@ -169,5 +169,5 @@ fn string_parameters() {
     let expected_state = executed_state::scalar_string("arg1");
 
     assert_eq!(actual_trace.len(), 2);
-    assert_eq!(actual_trace[1], expected_state);
+    assert_eq!(actual_trace[1.into()], expected_state);
 }

air/tests/test_module/instructions/fold.rs

@@ -44,11 +44,11 @@ fn lfold() {
     let expected_state = executed_state::scalar_string_array(vec!["1", "2", "3", "4", "5"]);
 
     assert_eq!(actual_trace.len(), 6);
-    assert_eq!(actual_trace[0], expected_state);
+    assert_eq!(actual_trace[0.into()], expected_state);
 
     for i in 1..=5 {
         let expected_state = executed_state::stream_string(format!("{}", i), i as u32 - 1);
-        assert_eq!(actual_trace[i], expected_state);
+        assert_eq!(actual_trace[i.into()], expected_state);
     }
 }
 
@@ -78,11 +78,11 @@ fn rfold() {
     assert_eq!(actual_trace.len(), 6);
 
     let expected_state = executed_state::scalar_string_array(vec!["1", "2", "3", "4", "5"]);
-    assert_eq!(actual_trace[0], expected_state);
+    assert_eq!(actual_trace[0.into()], expected_state);
 
     for i in 1..=5 {
         let expected_state = executed_state::stream_string(format!("{}", 6 - i), i as u32 - 1);
-        assert_eq!(actual_trace[i], expected_state);
+        assert_eq!(actual_trace[i.into()], expected_state);
     }
 }
 
@@ -120,14 +120,14 @@ fn inner_fold() {
     assert_eq!(actual_trace.len(), 27);
 
     let expected_state = executed_state::scalar_string_array(vec!["1", "2", "3", "4", "5"]);
-    assert_eq!(actual_trace[0], expected_state);
+    assert_eq!(actual_trace[0.into()], expected_state);
-    assert_eq!(actual_trace[1], expected_state);
+    assert_eq!(actual_trace[1.into()], expected_state);
 
     for i in 1..=5 {
         for j in 1..=5 {
             let state_id = 1 + 5 * (i - 1) + j;
             let expected_state = executed_state::stream_string(i.to_string(), state_id as u32 - 2);
-            assert_eq!(actual_trace[state_id], expected_state);
+            assert_eq!(actual_trace[state_id.into()], expected_state);
         }
     }
 }
@@ -187,7 +187,7 @@ fn empty_iterable_fold() {
     let expected_state = executed_state::scalar(json!([]));
 
     assert_eq!(actual_trace.len(), 1);
-    assert_eq!(actual_trace[0], expected_state);
+    assert_eq!(actual_trace[0.into()], expected_state);
 }
 
 #[test]
@@ -286,11 +286,11 @@ fn lambda() {
     let expected_state = executed_state::scalar(json!({ "array": ["1", "2", "3", "4", "5"] }));
 
     assert_eq!(actual_trace.len(), 6);
-    assert_eq!(actual_trace[0], expected_state);
+    assert_eq!(actual_trace[0.into()], expected_state);
 
     for i in 1..=5 {
         let expected_state = executed_state::stream_string(format!("{}", i), i as u32 - 1);
-        assert_eq!(actual_trace[i], expected_state);
+        assert_eq!(actual_trace[i.into()], expected_state);
     }
 }
 

air/tests/test_module/instructions/match_.rs

@@ -46,7 +46,7 @@ fn match_equal() {
     let expected_state = executed_state::scalar_string("result_1");
 
     assert_eq!(actual_trace.len(), 3);
-    assert_eq!(actual_trace[2], expected_state);
+    assert_eq!(actual_trace[2.into()], expected_state);
 }
 
 #[test]
@@ -78,7 +78,7 @@ fn match_not_equal() {
     let expected_state = executed_state::scalar_string("result_2");
 
     assert_eq!(actual_trace.len(), 3);
-    assert_eq!(actual_trace[2], expected_state);
+    assert_eq!(actual_trace[2.into()], expected_state);
 }
 
 #[test]
@@ -107,7 +107,7 @@ fn match_with_string() {
     let expected_state = executed_state::scalar_string("result_1");
 
     assert_eq!(actual_trace.len(), 2);
-    assert_eq!(actual_trace[1], expected_state);
+    assert_eq!(actual_trace[1.into()], expected_state);
 }
 
 #[test]
@@ -137,7 +137,7 @@ fn match_with_init_peer_id() {
     let expected_executed_call_result = executed_state::scalar_string("result_1");
 
     assert_eq!(actual_trace.len(), 2);
-    assert_eq!(actual_trace[1], expected_executed_call_result);
+    assert_eq!(actual_trace[1.into()], expected_executed_call_result);
 }
 
 #[test]
@@ -168,7 +168,7 @@ fn match_with_timestamp() {
     let expected_executed_call_result = executed_state::scalar_string("result_1");
 
     assert_eq!(actual_trace.len(), 2);
-    assert_eq!(actual_trace[1], expected_executed_call_result);
+    assert_eq!(actual_trace[1.into()], expected_executed_call_result);
 }
 
 #[test]
@@ -199,7 +199,7 @@ fn match_with_ttl() {
     let expected_executed_call_result = executed_state::scalar_string("result_1");
 
     assert_eq!(actual_trace.len(), 2);
-    assert_eq!(actual_trace[1], expected_executed_call_result);
+    assert_eq!(actual_trace[1.into()], expected_executed_call_result);
 }
 
 #[test]

air/tests/test_module/instructions/mismatch.rs

@@ -46,7 +46,7 @@ fn mismatch_equal() {
     let expected_state = executed_state::scalar_string("result_2");
 
     assert_eq!(actual_trace.len(), 3);
-    assert_eq!(actual_trace[2], expected_state);
+    assert_eq!(actual_trace[2.into()], expected_state);
 }
 
 #[test]
@@ -78,7 +78,7 @@ fn mismatch_not_equal() {
     let expected_state = executed_state::scalar_string("result_1");
 
     assert_eq!(actual_trace.len(), 3);
-    assert_eq!(actual_trace[2], expected_state);
+    assert_eq!(actual_trace[2.into()], expected_state);
 }
 
 #[test]
@@ -107,7 +107,7 @@ fn mismatch_with_string() {
     let expected_state = executed_state::scalar_string("result_2");
 
     assert_eq!(actual_trace.len(), 2);
-    assert_eq!(actual_trace[1], expected_state);
+    assert_eq!(actual_trace[1.into()], expected_state);
 }
 
 #[test]

air/tests/test_module/instructions/new.rs

@@ -74,8 +74,8 @@ fn new_with_global_streams_seq() {
         executed_state::stream_number(1, 0),
         executed_state::stream_number(2, 0),
         executed_state::fold(vec![
-            executed_state::subtrace_lore(0, SubTraceDesc::new(3, 1), SubTraceDesc::new(7, 2)),
+            executed_state::subtrace_lore(0, SubTraceDesc::new(3.into(), 1), SubTraceDesc::new(7.into(), 2)),
-            executed_state::subtrace_lore(1, SubTraceDesc::new(4, 1), SubTraceDesc::new(5, 2)),
+            executed_state::subtrace_lore(1, SubTraceDesc::new(4.into(), 1), SubTraceDesc::new(5.into(), 2)),
         ]),
         executed_state::stream_number(1, 0),
         executed_state::stream_number(2, 0),

air/tests/test_module/instructions/xor.rs

@@ -36,10 +36,10 @@ fn xor() {
 
     assert_eq!(actual_trace.len(), 2);
     assert_eq!(
-        actual_trace[0],
+        actual_trace[0.into()],
         executed_state::service_failed(1, "failed result from fallible_call_service")
     );
-    assert_eq!(actual_trace[1], expected_call_result);
+    assert_eq!(actual_trace[1.into()], expected_call_result);
 
     let script = f!(r#"
             (xor
@@ -51,7 +51,7 @@ fn xor() {
 
     let actual_trace = trace_from_result(&result);
     assert_eq!(actual_trace.len(), 1);
-    assert_eq!(actual_trace[0], expected_call_result);
+    assert_eq!(actual_trace[0.into()], expected_call_result);
 }
 
 #[test]
@@ -71,8 +71,8 @@ fn xor_var_not_found() {
     let result = checked_call_vm!(vm, <_>::default(), script, "", "");
 
     let actual_trace = trace_from_result(&result);
-    assert_eq!(actual_trace[0], executed_state::par(1, 0));
+    assert_eq!(actual_trace[0.into()], executed_state::par(1, 0));
-    assert_eq!(actual_trace[1], executed_state::request_sent_by(local_peer_id));
+    assert_eq!(actual_trace[1.into()], executed_state::request_sent_by(local_peer_id));
 }
 
 #[test]
@@ -171,5 +171,5 @@ fn last_error_with_xor() {
         r#"Local service error, ret_code is 1, error message is '"failed result from fallible_call_service"'"#,
     );
 
-    assert_eq!(actual_trace[1], expected_state);
+    assert_eq!(actual_trace[1.into()], expected_state);
 }

air/tests/test_module/issues/issue_173.rs

@@ -75,8 +75,8 @@ fn issue_173() {
         executed_state::stream_number(1, 0),
         executed_state::stream_number(2, 0),
         executed_state::fold(vec![
-            executed_state::subtrace_lore(0, SubTraceDesc::new(3, 2), SubTraceDesc::new(9, 2)),
+            executed_state::subtrace_lore(0, SubTraceDesc::new(3.into(), 2), SubTraceDesc::new(9.into(), 2)),
-            executed_state::subtrace_lore(1, SubTraceDesc::new(5, 2), SubTraceDesc::new(7, 2)),
+            executed_state::subtrace_lore(1, SubTraceDesc::new(5.into(), 2), SubTraceDesc::new(7.into(), 2)),
         ]),
         executed_state::par(6, 1),
         executed_state::stream_number(1, 0),

air/tests/test_module/issues/issue_221.rs

@@ -94,8 +94,8 @@ fn issue_221() {
         executed_state::scalar_string(peer_2_value),
         executed_state::ap(Some(1)),
         executed_state::fold(vec![
-            executed_state::subtrace_lore(3, SubTraceDesc::new(8, 4), SubTraceDesc::new(12, 0)),
+            executed_state::subtrace_lore(3, SubTraceDesc::new(8.into(), 4), SubTraceDesc::new(12.into(), 0)),
-            executed_state::subtrace_lore(6, SubTraceDesc::new(12, 4), SubTraceDesc::new(16, 0)),
+            executed_state::subtrace_lore(6, SubTraceDesc::new(12.into(), 4), SubTraceDesc::new(16.into(), 0)),
         ]),
         executed_state::par(3, 0),
         executed_state::par(1, 1),

air/tests/test_module/issues/issue_222.rs

@@ -70,8 +70,8 @@ fn issue_222() {
         executed_state::stream(json!([1]), 0),
         executed_state::stream(json!([2]), 0),
         executed_state::fold(vec![
-            executed_state::subtrace_lore(2, SubTraceDesc::new(5, 1), SubTraceDesc::new(7, 0)),
+            executed_state::subtrace_lore(2, SubTraceDesc::new(5.into(), 1), SubTraceDesc::new(7.into(), 0)),
-            executed_state::subtrace_lore(3, SubTraceDesc::new(6, 1), SubTraceDesc::new(7, 0)),
+            executed_state::subtrace_lore(3, SubTraceDesc::new(6.into(), 1), SubTraceDesc::new(7.into(), 0)),
         ]),
         executed_state::scalar(json!([1])),
         executed_state::scalar(json!([2])),

crates/air-lib/interpreter-data/src/executed_state.rs

@@ -17,6 +17,8 @@
 mod impls;
 mod se_de;
 
+use crate::TracePos;
+
 use se_de::par_serializer;
 use se_de::sender_serializer;
 use serde::Deserialize;
@@ -82,7 +84,7 @@ pub enum Value {
 pub struct FoldSubTraceLore {
     /// Position of current value in a trace.
     #[serde(rename = "pos")]
-    pub value_pos: u32,
+    pub value_pos: TracePos,
 
     /// Descriptors of a subtrace that are corresponded to the current value. Technically, now
     /// it always contains two values, and Vec here is used to have a possibility to handle more
@@ -97,7 +99,7 @@ pub struct FoldSubTraceLore {
 pub struct SubTraceDesc {
     /// Start position in a trace of this subtrace.
     #[serde(rename = "pos")]
-    pub begin_pos: u32,
+    pub begin_pos: TracePos,
 
     /// Length of the subtrace.
     #[serde(rename = "len")]

crates/air-lib/interpreter-data/src/executed_state/impls.rs

@@ -59,9 +59,9 @@ impl CallResult {
 }
 
 impl SubTraceDesc {
-    pub fn new(begin_pos: usize, subtrace_len: usize) -> Self {
+    pub fn new(begin_pos: TracePos, subtrace_len: usize) -> Self {
         Self {
-            begin_pos: begin_pos as _,
+            begin_pos,
             subtrace_len: subtrace_len as _,
         }
     }

crates/air-lib/interpreter-data/src/interpreter_data.rs

@@ -14,16 +14,14 @@
  * limitations under the License.
  */
 
-use super::ExecutedState;
 use super::GlobalStreamGens;
 use super::RestrictedStreamGens;
 use super::DATA_FORMAT_VERSION;
+use crate::ExecutionTrace;
 use serde::Deserialize;
 use serde::Serialize;
 use std::ops::Deref;
 
-pub type ExecutionTrace = Vec<ExecutedState>;
-
 /// The AIR interpreter could be considered as a function
 /// f(prev_data: InterpreterData, current_data: InterpreterData, ... ) -> (result_data: InterpreterData, ...).
 /// This function receives prev and current data and produces a result data. All these data

crates/air-lib/interpreter-data/src/lib.rs

@@ -28,10 +28,14 @@
 mod executed_state;
 mod interpreter_data;
 mod stream_generations;
+mod trace;
+mod trace_pos;
 
 pub use executed_state::*;
 pub use interpreter_data::*;
 pub use stream_generations::*;
+pub use trace::*;
+pub use trace_pos::*;
 
 use once_cell::sync::Lazy;
 use std::str::FromStr;

crates/air-lib/interpreter-data/src/trace.rs

@@ -0,0 +1,75 @@
+/*
+ * Copyright 2022 Fluence Labs Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use super::ExecutedState;
+use crate::TracePos;
+use serde::Deserialize;
+use serde::Serialize;
+use std::ops::Deref;
+use std::ops::Index;
+use std::ops::IndexMut;
+
+#[derive(Debug, Clone, Default, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(transparent)]
+pub struct ExecutionTrace(Vec<ExecutedState>);
+
+impl ExecutionTrace {
+    pub fn get(&self, index: TracePos) -> Option<&ExecutedState> {
+        self.0.get(usize::from(index))
+    }
+
+    pub fn pop(&mut self) -> Option<ExecutedState> {
+        self.0.pop()
+    }
+
+    pub fn push(&mut self, value: ExecutedState) {
+        self.0.push(value);
+    }
+}
+
+impl Deref for ExecutionTrace {
+    type Target = [ExecutedState];
+
+    fn deref(&self) -> &[ExecutedState] {
+        &self.0
+    }
+}
+
+impl From<Vec<ExecutedState>> for ExecutionTrace {
+    fn from(vec: Vec<ExecutedState>) -> Self {
+        Self(vec)
+    }
+}
+
+impl Index<TracePos> for ExecutionTrace {
+    type Output = ExecutedState;
+
+    fn index(&self, index: TracePos) -> &Self::Output {
+        &self.deref()[usize::from(index)]
+    }
+}
+
+impl IndexMut<TracePos> for ExecutionTrace {
+    fn index_mut(&mut self, index: TracePos) -> &mut Self::Output {
+        &mut self.0[usize::from(index)]
+    }
+}
+
+impl PartialEq<Vec<ExecutedState>> for ExecutionTrace {
+    fn eq(&self, other: &Vec<ExecutedState>) -> bool {
+        &self.0 == other
+    }
+}

crates/air-lib/interpreter-data/src/trace_pos.rs

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2022 Fluence Labs Limited
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+use serde::{Deserialize, Serialize};
+use std::{
+    fmt::{Debug, Display},
+    ops::{Add, AddAssign, Sub},
+};
+
+#[derive(Copy, Clone, Default, PartialEq, Eq, PartialOrd, Ord, Hash, Serialize, Deserialize)]
+#[serde(transparent)]
+#[repr(transparent)]
+pub struct TracePos(usize);
+
+impl TracePos {
+    pub fn checked_add(self, other: usize) -> Option<Self> {
+        self.0.checked_add(other).map(Self)
+    }
+}
+
+impl Debug for TracePos {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        Debug::fmt(&self.0, f)
+    }
+}
+
+impl Display for TracePos {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        Display::fmt(&self.0, f)
+    }
+}
+
+impl From<usize> for TracePos {
+    fn from(pos: usize) -> Self {
+        TracePos(pos)
+    }
+}
+
+impl From<TracePos> for usize {
+    fn from(pos: TracePos) -> Self {
+        pos.0
+    }
+}
+
+impl AddAssign<usize> for TracePos {
+    fn add_assign(&mut self, rhs: usize) {
+        self.0 += rhs;
+    }
+}
+
+impl Add<usize> for TracePos {
+    type Output = Self;
+
+    fn add(self, rhs: usize) -> Self::Output {
+        TracePos(self.0 + rhs)
+    }
+}
+
+impl Sub<usize> for TracePos {
+    type Output = Self;
+
+    fn sub(self, rhs: usize) -> Self::Output {
+        TracePos(self.0 - rhs)
+    }
+}
+
+impl Sub<TracePos> for TracePos {
+    type Output = usize;
+
+    fn sub(self, rhs: TracePos) -> Self::Output {
+        self.0 - rhs.0
+    }
+}

crates/air-lib/test-utils/src/executed_state.rs

@@ -20,6 +20,7 @@ use super::ExecutedState;
 use super::JValue;
 use super::ParResult;
 use super::Sender;
+use super::TracePos;
 use super::Value;
 use crate::FoldLore;
 use crate::FoldResult;
@@ -113,16 +114,23 @@ pub fn fold(lore: FoldLore) -> ExecutedState {
 }
 
 pub fn subtrace_lore(
-    value_pos: u32,
+    value_pos: usize,
     before: SubTraceDesc,
     after: SubTraceDesc,
 ) -> FoldSubTraceLore {
     FoldSubTraceLore {
-        value_pos,
+        value_pos: value_pos.into(),
         subtraces_desc: vec![before, after],
     }
 }
 
+pub fn subtrace_desc(begin_pos: impl Into<TracePos>, subtrace_len: u32) -> SubTraceDesc {
+    SubTraceDesc {
+        begin_pos: begin_pos.into(),
+        subtrace_len,
+    }
+}
+
 pub fn ap(dst: Option<u32>) -> ExecutedState {
     let res_generations = option_to_vec(dst);
     let ap_result = ApResult::new(res_generations);

crates/air-lib/test-utils/src/lib.rs

@@ -89,8 +89,9 @@ pub fn data_from_result(result: &RawAVMOutcome) -> InterpreterData {
     serde_json::from_slice(&result.data).expect("default serializer shouldn't fail")
 }
 
-pub fn raw_data_from_trace(trace: ExecutionTrace) -> Vec<u8> {
+pub fn raw_data_from_trace(trace: impl Into<ExecutionTrace>) -> Vec<u8> {
-    let data = InterpreterData::from_execution_result(trace, <_>::default(), <_>::default(), 0);
+    let data =
+        InterpreterData::from_execution_result(trace.into(), <_>::default(), <_>::default(), 0);
     serde_json::to_vec(&data).expect("default serializer shouldn't fail")
 }
 

crates/air-lib/trace-handler/src/data_keeper/errors.rs

@@ -15,6 +15,7 @@
  */
 
 use super::ExecutedState;
+use crate::TracePos;
 use thiserror::Error as ThisError;
 
 /// Errors arose out while accessing various interpreter data.
@@ -27,7 +28,7 @@ pub enum KeeperError {
     )]
     SetSubtraceLenFailed {
         requested_subtrace_len: usize,
-        trace_position: usize,
+        trace_position: TracePos,
         trace_len: usize,
     },
 
@@ -38,7 +39,7 @@ pub enum KeeperError {
         but tried to set {requested_subtrace_len} subtrace_len and {requested_pos} position"
     )]
     SetSubtraceLenAndPosFailed {
-        requested_pos: usize,
+        requested_pos: TracePos,
         requested_subtrace_len: usize,
         trace_len: usize,
     },
@@ -46,7 +47,7 @@ pub enum KeeperError {
     /// Errors occurred when Fold FSM tries to obtain stream generation by value_pos from a trace,
     /// but this value_pos is bigger than the trace length.
     #[error("requested an element at position '{position}', but executed trace contains only '{trace_len}' elements")]
-    NoElementAtPosition { position: usize, trace_len: usize },
+    NoElementAtPosition { position: TracePos, trace_len: usize },
 
     /// Errors occurred when Fold FSM tries to obtain stream generation by value_pos from a trace,
     /// but such state doesn't belong to values in streams (it doesn't contain a generation).

crates/air-lib/trace-handler/src/data_keeper/keeper.rs

@@ -17,6 +17,7 @@
 use super::ExecutionTrace;
 use super::MergeCtx;
 use super::TraceSlider;
+use crate::TracePos;
 
 use air_interpreter_data::InterpreterData;
 
@@ -27,7 +28,7 @@ use std::collections::HashMap;
 pub(crate) struct DataKeeper {
     pub(crate) prev_ctx: MergeCtx,
     pub(crate) current_ctx: MergeCtx,
-    pub(crate) new_to_old_pos: HashMap<usize, DataPositions>,
+    pub(crate) new_to_old_pos: HashMap<TracePos, DataPositions>,
     pub(crate) result_trace: ExecutionTrace,
 }
 
@@ -48,6 +49,10 @@ impl DataKeeper {
         self.result_trace.len()
     }
 
+    pub(crate) fn result_trace_next_pos(&self) -> TracePos {
+        self.result_trace.len().into()
+    }
+
     pub(crate) fn prev_slider(&self) -> &TraceSlider {
         &self.prev_ctx.slider
     }
@@ -67,6 +72,6 @@ impl DataKeeper {
 
 #[derive(Debug, Default, Clone, Copy, PartialEq, Eq)]
 pub(crate) struct DataPositions {
-    pub(crate) prev_pos: Option<usize>,
+    pub(crate) prev_pos: Option<TracePos>,
-    pub(crate) current_pos: Option<usize>,
+    pub(crate) current_pos: Option<TracePos>,
 }

crates/air-lib/trace-handler/src/data_keeper/merge_ctx.rs

@@ -18,6 +18,7 @@ use super::ExecutionTrace;
 use super::KeeperError;
 use super::KeeperResult;
 use super::TraceSlider;
+use crate::TracePos;
 
 use air_interpreter_data::GlobalStreamGens;
 use air_interpreter_data::InterpreterData;
@@ -51,10 +52,9 @@ impl MergeCtx {
         }
     }
 
-    pub(crate) fn try_get_generation(&self, position: u32) -> KeeperResult<u32> {
+    pub(crate) fn try_get_generation(&self, position: TracePos) -> KeeperResult<u32> {
         use air_interpreter_data::*;
 
-        let position = position as usize;
         let state = self
             .slider
             .state_at_position(position)

crates/air-lib/trace-handler/src/data_keeper/trace_slider.rs

@@ -18,6 +18,7 @@ use super::ExecutedState;
 use super::ExecutionTrace;
 use super::KeeperError::*;
 use super::KeeperResult;
+use crate::TracePos;
 
 /// This slider is intended to slide on a subtrace inside provided trace. This subtrace
 /// is identified by position and len.
@@ -28,7 +29,7 @@ pub struct TraceSlider {
     trace: ExecutionTrace,
 
     /// Position of current subtrace inside trace.
-    position: usize,
+    position: TracePos,
 
     /// Length of a current subtrace.
     subtrace_len: usize,
@@ -38,7 +39,8 @@ pub struct TraceSlider {
 }
 
 impl TraceSlider {
-    pub(crate) fn new(trace: ExecutionTrace) -> Self {
+    pub(crate) fn new(trace: impl Into<ExecutionTrace>) -> Self {
+        let trace = trace.into();
         let subtrace_len = trace.len();
 
         Self {
@@ -52,7 +54,7 @@ impl TraceSlider {
     /// and None otherwise.
     #[allow(clippy::suspicious_operation_groupings)]
     pub(crate) fn next_state(&mut self) -> Option<ExecutedState> {
-        if self.seen_elements >= self.subtrace_len || self.position >= self.trace.len() {
+        if self.seen_elements >= self.subtrace_len || usize::from(self.position) >= self.trace.len() {
             return None;
         }
 
@@ -62,9 +64,10 @@ impl TraceSlider {
         Some(result)
     }
 
-    pub(crate) fn set_position_and_len(&mut self, position: usize, subtrace_len: usize) -> KeeperResult<()> {
+    pub(crate) fn set_position_and_len(&mut self, position: TracePos, subtrace_len: usize) -> KeeperResult<()> {
+        let pos: usize = position.into();
         // it's possible to set empty subtrace_len and inconsistent position
-        if subtrace_len != 0 && position + subtrace_len > self.trace.len() {
+        if subtrace_len != 0 && pos + subtrace_len > self.trace.len() {
             return Err(SetSubtraceLenAndPosFailed {
                 requested_pos: position,
                 requested_subtrace_len: subtrace_len,
@@ -80,7 +83,7 @@ impl TraceSlider {
     }
 
     pub(crate) fn set_subtrace_len(&mut self, subtrace_len: usize) -> KeeperResult<()> {
-        let trace_remainder = self.trace.len() - self.position;
+        let trace_remainder = self.trace.len() - usize::from(self.position);
         if trace_remainder < subtrace_len {
             return Err(SetSubtraceLenFailed {
                 requested_subtrace_len: subtrace_len,
@@ -95,7 +98,7 @@ impl TraceSlider {
         Ok(())
     }
 
-    pub(crate) fn position(&self) -> usize {
+    pub(crate) fn position(&self) -> TracePos {
         self.position
     }
 
@@ -103,7 +106,8 @@ impl TraceSlider {
         self.subtrace_len - self.seen_elements
     }
 
-    pub(super) fn state_at_position(&self, position: usize) -> Option<&ExecutedState> {
+    pub(super) fn state_at_position(&self, position: TracePos) -> Option<&ExecutedState> {
+        // it would be nice to have the `impl SliceIndex for TracePos`, but it is unstable
         self.trace.get(position)
     }
 

crates/air-lib/trace-handler/src/handler.rs

@@ -38,8 +38,8 @@ impl TraceHandler {
 
     /// Returns size of elements inside result trace and intended to provide
     /// a position of next inserted elements.
-    pub fn trace_pos(&self) -> usize {
+    pub fn trace_pos(&self) -> TracePos {
-        self.data_keeper.result_trace.len()
+        self.data_keeper.result_trace.len().into()
     }
 
     pub fn into_result_trace(self) -> ExecutionTrace {
@@ -120,7 +120,7 @@ impl TraceHandler {
         Ok(())
     }
 
-    pub fn meet_iteration_start(&mut self, fold_id: u32, value_pos: usize) -> TraceHandlerResult<()> {
+    pub fn meet_iteration_start(&mut self, fold_id: u32, value_pos: TracePos) -> TraceHandlerResult<()> {
         let fold_fsm = self.fsm_keeper.fold_mut(fold_id)?;
         fold_fsm.meet_iteration_start(value_pos, &mut self.data_keeper)?;
 

crates/air-lib/trace-handler/src/merger/call_merger.rs

@@ -17,6 +17,7 @@
 mod utils;
 
 use super::*;
+use crate::TracePos;
 use air_parser::ast::CallOutputValue;
 use utils::*;
 
@@ -29,7 +30,7 @@ pub enum MergerCallResult {
 
     /// There was a state in at least one of the contexts. If there were two states in
     /// both contexts, they were successfully merged.
-    CallResult { value: CallResult, trace_pos: usize },
+    CallResult { value: CallResult, trace_pos: TracePos },
 }
 
 pub(crate) fn try_merge_next_state_as_call(
@@ -102,7 +103,7 @@ pub(super) fn prepare_call_result(
     scheme: PreparationScheme,
     data_keeper: &mut DataKeeper,
 ) -> MergerCallResult {
-    let trace_pos = data_keeper.result_states_count();
+    let trace_pos = data_keeper.result_trace_next_pos();
     prepare_positions_mapping(scheme, data_keeper);
 
     MergerCallResult::CallResult { value, trace_pos }

crates/air-lib/trace-handler/src/merger/errors.rs

@@ -22,6 +22,7 @@ use super::FoldResult;
 use super::KeeperError;
 use super::Value;
 
+use air_interpreter_data::TracePos;
 use thiserror::Error as ThisError;
 
 /// Errors arose out of merging previous data with a new.
@@ -79,7 +80,7 @@ pub enum FoldResultError {
 
     /// There are several lores with the same value_pos.
     #[error("{0:?} contains several subtraces with the same value_pos {1}")]
-    SeveralRecordsWithSamePos(FoldResult, usize),
+    SeveralRecordsWithSamePos(FoldResult, TracePos),
 
     /// Errors occurred when one of the fold subtrace lore doesn't contain 2 descriptors.
     #[error("fold contains {0} sublore descriptors, but 2 is expected")]

crates/air-lib/trace-handler/src/merger/fold_merger/fold_lore_resolver.rs

@@ -19,12 +19,13 @@ use crate::data_keeper::MergeCtx;
 
 use air_interpreter_data::FoldSubTraceLore;
 use air_interpreter_data::SubTraceDesc;
+use air_interpreter_data::TracePos;
 
 use std::collections::HashMap;
 
 #[derive(Debug, Default, Clone, PartialEq, Eq)]
 pub struct ResolvedFold {
-    pub lore: HashMap<usize, ResolvedSubTraceDescs>,
+    pub lore: HashMap<TracePos, ResolvedSubTraceDescs>,
     pub fold_states_count: usize,
 }
 
@@ -40,16 +41,14 @@ pub(super) fn resolve_fold_lore(fold: &FoldResult, merge_ctx: &MergeCtx) -> Merg
     let lore = fold.lore.iter().zip(lens).try_fold::<_, _, MergeResult<_>>(
         HashMap::with_capacity(fold.lore.len()),
         |mut resolved_lore, (lore, lens)| {
-            let before_subtrace = SubTraceDesc::new(lore.subtraces_desc[0].begin_pos as _, lens.before_len as _);
+            let before_subtrace = SubTraceDesc::new(lore.subtraces_desc[0].begin_pos, lens.before_len as _);
-            let after_subtrace = SubTraceDesc::new(lore.subtraces_desc[1].begin_pos as _, lens.after_len as _);
+            let after_subtrace = SubTraceDesc::new(lore.subtraces_desc[1].begin_pos, lens.after_len as _);
             let resolved_descs = ResolvedSubTraceDescs::new(before_subtrace, after_subtrace);
 
-            match resolved_lore.insert(lore.value_pos as usize, resolved_descs) {
+            match resolved_lore.insert(lore.value_pos, resolved_descs) {
-                Some(_) => Err(FoldResultError::SeveralRecordsWithSamePos(
+                Some(_) => {
-                    fold.clone(),
+                    Err(FoldResultError::SeveralRecordsWithSamePos(fold.clone(), lore.value_pos)).map_err(Into::into)
-                    lore.value_pos as usize,
+                }
-                ))
-                .map_err(Into::into),
                 None => Ok(resolved_lore),
             }
         },
@@ -156,7 +155,7 @@ fn check_subtrace_lore(subtrace_lore: &FoldSubTraceLore) -> MergeResult<()> {
 }
 
 impl ResolvedFold {
-    pub(crate) fn new(lore: HashMap<usize, ResolvedSubTraceDescs>, fold_states_count: usize) -> Self {
+    pub(crate) fn new(lore: HashMap<TracePos, ResolvedSubTraceDescs>, fold_states_count: usize) -> Self {
         Self {
             lore,
             fold_states_count,
@@ -196,6 +195,14 @@ mod tests {
     use air_interpreter_data::FoldResult;
     use air_interpreter_data::FoldSubTraceLore;
     use air_interpreter_data::SubTraceDesc;
+    use air_interpreter_data::TracePos;
+
+    fn subtrace_desc(begin_pos: impl Into<TracePos>, subtrace_len: u32) -> SubTraceDesc {
+        SubTraceDesc {
+            begin_pos: begin_pos.into(),
+            subtrace_len,
+        }
+    }
 
     #[test]
     fn empty_fold_result() {
@@ -221,16 +228,16 @@ mod tests {
         //   g0     g0     g0
         let lore = vec![
             FoldSubTraceLore {
-                value_pos: 0,
+                value_pos: 0.into(),
-                subtraces_desc: vec![SubTraceDesc::new(0, 1), SubTraceDesc::new(0, 1)],
+                subtraces_desc: vec![subtrace_desc(0, 1), subtrace_desc(0, 1)],
             },
             FoldSubTraceLore {
-                value_pos: 0,
+                value_pos: 0.into(),
-                subtraces_desc: vec![SubTraceDesc::new(0, 2), SubTraceDesc::new(0, 2)],
+                subtraces_desc: vec![subtrace_desc(0, 2), subtrace_desc(0, 2)],
             },
             FoldSubTraceLore {
-                value_pos: 0,
+                value_pos: 0.into(),
-                subtraces_desc: vec![SubTraceDesc::new(0, 3), SubTraceDesc::new(0, 3)],
+                subtraces_desc: vec![subtrace_desc(0, 3), subtrace_desc(0, 3)],
             },
         ];
 
@@ -256,28 +263,28 @@ mod tests {
         //   g0     g0     g0     g1     g1     g2
         let lore = vec![
             FoldSubTraceLore {
-                value_pos: 0,
+                value_pos: 0.into(),
-                subtraces_desc: vec![SubTraceDesc::new(0, 1), SubTraceDesc::new(0, 1)],
+                subtraces_desc: vec![subtrace_desc(0, 1), subtrace_desc(0, 1)],
             },
             FoldSubTraceLore {
-                value_pos: 0,
+                value_pos: 0.into(),
-                subtraces_desc: vec![SubTraceDesc::new(0, 2), SubTraceDesc::new(0, 2)],
+                subtraces_desc: vec![subtrace_desc(0, 2), subtrace_desc(0, 2)],
             },
             FoldSubTraceLore {
-                value_pos: 0,
+                value_pos: 0.into(),
-                subtraces_desc: vec![SubTraceDesc::new(0, 3), SubTraceDesc::new(0, 3)],
+                subtraces_desc: vec![subtrace_desc(0, 3), subtrace_desc(0, 3)],
             },
             FoldSubTraceLore {
-                value_pos: 1,
+                value_pos: 1.into(),
-                subtraces_desc: vec![SubTraceDesc::new(0, 4), SubTraceDesc::new(0, 4)],
+                subtraces_desc: vec![subtrace_desc(0, 4), subtrace_desc(0, 4)],
             },
             FoldSubTraceLore {
-                value_pos: 1,
+                value_pos: 1.into(),
-                subtraces_desc: vec![SubTraceDesc::new(0, 5), SubTraceDesc::new(0, 5)],
+                subtraces_desc: vec![subtrace_desc(0, 5), subtrace_desc(0, 5)],
             },
             FoldSubTraceLore {
-                value_pos: 2,
+                value_pos: 2.into(),
-                subtraces_desc: vec![SubTraceDesc::new(0, 1), SubTraceDesc::new(0, 1)],
+                subtraces_desc: vec![subtrace_desc(0, 1), subtrace_desc(0, 1)],
             },
         ];
 

crates/air-lib/trace-handler/src/merger/position_mapping.rs

@@ -40,6 +40,6 @@ pub(super) fn prepare_positions_mapping(scheme: PreparationScheme, data_keeper:
 
     let data_positions = DataPositions { prev_pos, current_pos };
 
-    let trace_pos = data_keeper.result_states_count();
+    let trace_pos = data_keeper.result_trace_next_pos();
     data_keeper.new_to_old_pos.insert(trace_pos, data_positions);
 }

crates/air-lib/trace-handler/src/state_automata/errors.rs

@@ -18,6 +18,7 @@ use super::KeeperError;
 use super::ParResult;
 use crate::MergeCtxType;
 use crate::ResolvedFold;
+use crate::TracePos;
 
 use thiserror::Error as ThisError;
 
@@ -39,7 +40,7 @@ pub enum StateFSMError {
 
     /// Errors occurred when slider.position() + ParResult.0 + ParResult.1 overflows.
     #[error("overflow is occurred while calculating the new position of a {2} slider for resolved par {0:?} and current position {1}'")]
-    ParPosOverflow(ParResult, usize, MergeCtxType),
+    ParPosOverflow(ParResult, TracePos, MergeCtxType),
 
     /// Errors occurred when ParResult.0 + ParResult.1 value is bigger than current subgraph size.
     #[error("underflow is occurred while calculating the new position of a {2} slider for resolved par {0:?} and current subtrace len {1}'")]
@@ -47,11 +48,11 @@ pub enum StateFSMError {
 
     /// Errors occurred when {0}.fold_states_count + {1} overflows.
     #[error("overflow is occurred while calculating the new position of a {2} slider for resolved fold {0:?} and current position {1}'")]
-    FoldPosOverflow(ResolvedFold, usize, MergeCtxType),
+    FoldPosOverflow(ResolvedFold, TracePos, MergeCtxType),
 
     /// Errors occurred when {1} - 1{0}.fold_states_count underflows.
     #[error("underflow is occurred while calculating the new position of a {2} slider for resolved fold {0:?} and current subtrace len {1}'")]
-    FoldLenUnderflow(ResolvedFold, usize, MergeCtxType),
+    FoldLenUnderflow(ResolvedFold, TracePos, MergeCtxType),
 
     /// Errors bubbled from DataKeeper.
     #[error(transparent)]

crates/air-lib/trace-handler/src/state_automata/fold_fsm.rs

@@ -19,6 +19,8 @@ mod lore_ctor;
 mod lore_ctor_queue;
 mod state_handler;
 
+use crate::TracePos;
+
 use super::*;
 use lore_applier::*;
 use lore_ctor::*;
@@ -63,7 +65,7 @@ impl FoldFSM {
         Ok(fold_fsm)
     }
 
-    pub(crate) fn meet_iteration_start(&mut self, value_pos: usize, data_keeper: &mut DataKeeper) -> FSMResult<()> {
+    pub(crate) fn meet_iteration_start(&mut self, value_pos: TracePos, data_keeper: &mut DataKeeper) -> FSMResult<()> {
         let (prev_pos, current_pos) = match data_keeper.new_to_old_pos.get(&value_pos) {
             Some(DataPositions { prev_pos, current_pos }) => (prev_pos, current_pos),
             None => return self.prepare(None, None, value_pos, data_keeper),
@@ -79,7 +81,7 @@ impl FoldFSM {
         &mut self,
         prev_lore: Option<ResolvedSubTraceDescs>,
         current_lore: Option<ResolvedSubTraceDescs>,
-        value_pos: usize,
+        value_pos: TracePos,
         data_keeper: &mut DataKeeper,
     ) -> FSMResult<()> {
         apply_fold_lore_before(data_keeper, &prev_lore, &current_lore)?;

crates/air-lib/trace-handler/src/state_automata/fold_fsm/lore_ctor.rs

@@ -20,7 +20,7 @@ use air_interpreter_data::SubTraceDesc;
 /// This struct is a form of FSM and is intended to construct a fold subtrace lore element.
 #[derive(Debug, Default, PartialEq, Eq, Clone, Copy)]
 pub(super) struct SubTraceLoreCtor {
-    value_pos: usize,
+    value_pos: TracePos,
     before_tracker: PositionsTracker,
     after_tracker: PositionsTracker,
     state: CtorState,
@@ -28,8 +28,8 @@ pub(super) struct SubTraceLoreCtor {
 
 #[derive(Debug, Default, PartialEq, Eq, Clone, Copy)]
 struct PositionsTracker {
-    pub(self) start_pos: usize,
+    pub(self) start_pos: TracePos,
-    pub(self) end_pos: usize,
+    pub(self) end_pos: TracePos,
 }
 
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
@@ -41,10 +41,10 @@ pub enum CtorState {
 }
 
 impl SubTraceLoreCtor {
-    pub(super) fn from_before_start(value_pos: usize, data_keeper: &DataKeeper) -> Self {
+    pub(super) fn from_before_start(value_pos: TracePos, data_keeper: &DataKeeper) -> Self {
         let before_tracker = PositionsTracker {
-            start_pos: data_keeper.result_states_count(),
+            start_pos: data_keeper.result_trace_next_pos(),
-            end_pos: 0,
+            end_pos: 0.into(),
         };
 
         Self {
@@ -55,7 +55,7 @@ impl SubTraceLoreCtor {
     }
 
     pub(super) fn before_end(&mut self, data_keeper: &DataKeeper) {
-        self.before_tracker.end_pos = data_keeper.result_states_count();
+        self.before_tracker.end_pos = data_keeper.result_trace_next_pos();
         self.state.next();
     }
 
@@ -64,33 +64,33 @@ impl SubTraceLoreCtor {
             return;
         }
 
-        self.before_tracker.end_pos = data_keeper.result_states_count();
+        self.before_tracker.end_pos = data_keeper.result_trace_next_pos();
         self.state.next();
     }
 
     pub(super) fn after_start(&mut self, data_keeper: &DataKeeper) {
-        self.after_tracker.start_pos = data_keeper.result_states_count();
+        self.after_tracker.start_pos = data_keeper.result_trace_next_pos();
         self.state.next();
     }
 
     pub(super) fn after_end(&mut self, data_keeper: &DataKeeper) {
-        self.after_tracker.end_pos = data_keeper.result_states_count();
+        self.after_tracker.end_pos = data_keeper.result_trace_next_pos();
         self.state.next();
     }
 
     pub(super) fn into_subtrace_lore(self) -> FoldSubTraceLore {
         let before = SubTraceDesc {
-            begin_pos: self.before_tracker.start_pos as _,
+            begin_pos: self.before_tracker.start_pos,
             subtrace_len: self.before_tracker.len() as _,
         };
 
         let after = SubTraceDesc {
-            begin_pos: self.after_tracker.start_pos as _,
+            begin_pos: self.after_tracker.start_pos,
             subtrace_len: self.after_tracker.len() as _,
         };
 
         FoldSubTraceLore {
-            value_pos: self.value_pos as _,
+            value_pos: self.value_pos,
             subtraces_desc: vec![before, after],
         }
     }

crates/air-lib/trace-handler/src/state_automata/fold_fsm/state_handler.rs

@@ -58,6 +58,7 @@ fn compute_new_state(fold: &ResolvedFold, data_keeper: &DataKeeper, ctx_type: Me
     let current_len = ctx.slider.subtrace_len();
     let subtrace_len = current_len
         .checked_sub(fold.fold_states_count)
+        // TODO judging by the error message, one should pass current_len instead.
         .ok_or_else(|| StateFSMError::FoldLenUnderflow(fold.clone(), current_position, ctx_type))?;
 
     let state = CtxState::new(pos, subtrace_len);

crates/air-lib/trace-handler/src/state_automata/state_inserter.rs

@@ -16,18 +16,19 @@
 
 use super::DataKeeper;
 use super::ExecutedState;
+use air_interpreter_data::TracePos;
 
 /// This one is intended to optimize insertion in data to avoid insertion in a middle of it.
 /// This is achieved by inserting a temporary state, track insert position and insert there
 /// the final state.
 #[derive(Debug, Default, Clone)]
 pub(super) struct StateInserter {
-    position: usize,
+    position: TracePos,
 }
 
 impl StateInserter {
     pub(super) fn from_keeper(data_keeper: &mut DataKeeper) -> Self {
-        let position = data_keeper.result_trace.len();
+        let position = data_keeper.result_trace_next_pos();
         // this par is a temporary state
         data_keeper.result_trace.push(ExecutedState::par(0, 0));
 

crates/air-lib/trace-handler/src/state_automata/utils.rs

@@ -17,10 +17,11 @@
 use super::DataKeeper;
 use super::FSMResult;
 use super::MergeCtx;
+use crate::TracePos;
 
 #[derive(Debug, Default, Clone, Copy)]
 pub(super) struct CtxState {
-    pub(super) pos: usize,
+    pub(super) pos: TracePos,
     pub(super) subtrace_len: usize,
 }
 
@@ -31,7 +32,7 @@ pub(super) struct CtxStatesPair {
 }
 
 impl CtxState {
-    pub(super) fn new(pos: usize, subtrace_len: usize) -> Self {
+    pub(super) fn new(pos: TracePos, subtrace_len: usize) -> Self {
         Self { pos, subtrace_len }
     }