feat(air-interpreter)!: rkyv-serialized JValues

air/src/execution_step/execution_context/cid_state.rs

@@ -24,7 +24,6 @@ use air_interpreter_data::CanonCidAggregate;
 use air_interpreter_data::CanonResultCidAggregate;
 use air_interpreter_data::CidInfo;
 use air_interpreter_data::CidTracker;
-use air_interpreter_data::RawValue;
 use air_interpreter_data::ServiceResultCidAggregate;
 use air_interpreter_data::TracePos;
 use polyplets::SecurityTetraplet;
@@ -33,7 +32,7 @@ use std::rc::Rc;
 
 #[derive(Debug, Default, Clone)]
 pub struct ExecutionCidState {
-    pub value_tracker: CidTracker<RawValue>,
+    pub value_tracker: CidTracker<JValue>,
     pub tetraplet_tracker: CidTracker<SecurityTetraplet>,
     pub canon_element_tracker: CidTracker<CanonCidAggregate>,
     pub canon_result_tracker: CidTracker<CanonResultCidAggregate>,
@@ -73,8 +72,7 @@ impl ExecutionCidState {
         tetraplet: RcSecurityTetraplet,
         argument_hash: Rc<str>,
     ) -> Result<CID<ServiceResultCidAggregate>, UncatchableError> {
-        let vm_value = RawValue::from_value(value);
-        let value_cid = self.value_tracker.track_raw_value(vm_value);
+        let value_cid = self.value_tracker.track_value(value)?;
         let tetraplet_cid = self.tetraplet_tracker.track_value(tetraplet)?;
         let service_result_agg = ServiceResultCidAggregate::new(value_cid, argument_hash, tetraplet_cid);
 
@@ -87,8 +85,8 @@ impl ExecutionCidState {
         &mut self,
         canon_value: &ValueAggregate,
     ) -> Result<CID<CanonCidAggregate>, UncatchableError> {
-        let vm_value = RawValue::from_value(canon_value.get_result().clone());
-        let value_cid = self.value_tracker.track_raw_value(vm_value);
+        let value = canon_value.get_result().clone();
+        let value_cid = self.value_tracker.track_value(value)?;
         let tetraplet = self.tetraplet_tracker.track_value(canon_value.get_tetraplet())?;
 
         let canon_value_aggregate = CanonCidAggregate::new(value_cid, tetraplet, canon_value.get_provenance());
@@ -97,11 +95,11 @@ impl ExecutionCidState {
             .map_err(UncatchableError::from)
     }
 
-    pub(crate) fn get_value_by_cid(&self, cid: &CID<RawValue>) -> Result<JValue, UncatchableError> {
+    pub(crate) fn get_value_by_cid(&self, cid: &CID<JValue>) -> Result<JValue, UncatchableError> {
         self.value_tracker
             .get(cid)
             .ok_or_else(|| UncatchableError::ValueForCidNotFound("value", cid.get_inner()))
-            .map(|vm_value| vm_value.get_value())
+            .map(|rc_value| (*rc_value).clone())
     }
 
     pub(crate) fn get_tetraplet_by_cid(

air/src/execution_step/lambda_applier/utils.rs

@@ -124,11 +124,11 @@ fn try_jvalue_as_idx(jvalue: &JValue) -> LambdaResult<u32> {
     }
 }
 
-fn try_number_to_u32(accessor: &serde_json::Number) -> LambdaResult<u32> {
+fn try_number_to_u32(accessor: &air_interpreter_value::Number) -> LambdaResult<u32> {
     accessor
         .as_u64()
         .and_then(|v| u32::try_from(v).ok())
         .ok_or(LambdaError::IndexAccessNotU32 {
-            accessor: accessor.clone(),
+            accessor: accessor.clone().into(),
         })
 }

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

@@ -331,12 +331,7 @@ fn fold_merge() {
                     };
 
                     let service_result_agg = data.cid_info.service_result_store.get(cid).unwrap();
-                    let value = data
-                        .cid_info
-                        .value_store
-                        .get(&service_result_agg.value_cid)
-                        .unwrap()
-                        .get_value();
+                    let value = &*data.cid_info.value_store.get(&service_result_agg.value_cid).unwrap();
 
                     if let JValue::String(ref var_name) = value {
                         let current_count: usize = calls_count.get(var_name).copied().unwrap_or_default();

air/tests/test_module/features/signatures/corruption.rs

@@ -58,7 +58,7 @@ fn test_attack_replace_value() {
     let mut mallory_cid_info = serde_json::to_value::<CidInfo>(mallory_cid_state.into()).unwrap();
     let mut cnt = 0;
     for (_cid, val) in mallory_cid_info["value_store"].as_object_mut().unwrap().iter_mut() {
-        if val.as_str().unwrap() == json!("alice").to_string() {
+        if val.as_str().unwrap() == json!("alice") {
             *val = json!("evil").to_string().into();
             cnt += 1;
         }
@@ -96,7 +96,7 @@ fn test_attack_replace_value() {
         PreparationError::CidStoreVerificationError(
             CidVerificationError::ValueMismatch {
                 // fragile: it is OK if this exact string changes on compiler upgrade
-                type_name: "air_interpreter_data::raw_value::RawValue",
+                type_name: "air_interpreter_value::value::JValue",
                 cid_repr: "bagaaihrayhxgqijfajraxivb7hxwshhbsdqk4j5zyqypb54zggmn5v7mmwxq".into(),
             }
             .into()

air/tests/test_module/negative_tests/uncatchable_trace_unrelated.rs

@@ -17,7 +17,6 @@
 use air::interpreter_data::ExecutedState;
 use air::ExecutionCidState;
 use air::UncatchableError::*;
-use air_interpreter_data::RawValue;
 use air_interpreter_data::ValueRef;
 use air_test_framework::AirScriptExecutor;
 use air_test_utils::prelude::*;
@@ -139,10 +138,8 @@ fn malformed_call_service_failed() {
     let mut cid_state = ExecutionCidState::new();
 
     // Craft an artificial incorrect error result
-    let value = json!("error");
-    let value_cid = cid_state
-        .value_tracker
-        .track_raw_value(RawValue::from_value(value.clone()));
+    let value: JValue = "error".into();
+    let value_cid = cid_state.value_tracker.track_value(value.clone()).unwrap();
     let tetraplet = SecurityTetraplet::literal_tetraplet(peer_id);
     let tetraplet_cid = cid_state.tetraplet_tracker.track_value(tetraplet).unwrap();
     let service_result_agg = ServiceResultCidAggregate {
@@ -161,7 +158,7 @@ fn malformed_call_service_failed() {
     let mut vm = create_avm(unit_call_service(), peer_id);
     let air = format!(r#"(call "{peer_id}" ("" "") [] var)"#);
     let result = vm.call(&air, vec![], data, TestRunParameters::default()).unwrap();
-    let expected_serde_error = serde_json::from_value::<CallServiceFailed>(value).unwrap_err();
+    let expected_serde_error = serde_json::from_value::<CallServiceFailed>(value.into()).unwrap_err();
     let expected_error = MalformedCallServiceFailed(expected_serde_error);
     assert_error_eq!(&result, expected_error);
 }