Store RawValue as JValue

air/src/execution_step/execution_context/instruction_error/instruction_error_definition.rs

@@ -107,9 +107,7 @@ fn ensure_error_code_correct(
     field_name: &'static str,
 ) -> Result<(), ErrorObjectError> {
     match value {
-        JValue::Number(number) if number.is_i64() | number.is_u64() => {
-            ensure_error_code_is_error(number.as_i64().unwrap())
-        }
+        JValue::Number(number) => ensure_error_code_is_error(*number),
         _ => Err(ErrorObjectError::ScalarFieldIsWrongType {
             scalar: scalar.clone(),
             field_name,

air/src/execution_step/execution_context/stream_maps_variables/stream_map_key.rs

@@ -36,8 +36,7 @@ impl StreamMapKey {
     pub fn from_value(value: JValue) -> Option<Self> {
         match value {
             JValue::String(s) => Some(StreamMapKey::Str(s)),
-            JValue::Number(n) if n.is_i64() => Some(StreamMapKey::I64(n.as_i64().unwrap())),
-            JValue::Number(n) if n.is_u64() => Some(StreamMapKey::U64(n.as_u64().unwrap())),
+            JValue::Number(n) => Some(StreamMapKey::I64(n)),
             _ => None,
         }
     }
@@ -45,8 +44,7 @@ impl StreamMapKey {
     pub fn from_value_ref(value: &JValue) -> Option<Self> {
         match value {
             JValue::String(s) => Some(StreamMapKey::Str(s.clone())),
-            JValue::Number(n) if n.is_i64() => Some(StreamMapKey::I64(n.as_i64().unwrap())),
-            JValue::Number(n) if n.is_u64() => Some(StreamMapKey::U64(n.as_u64().unwrap())),
+            JValue::Number(n) => Some(StreamMapKey::I64(*n)),
             _ => None,
         }
     }

air/src/execution_step/lambda_applier/utils.rs

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

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

@@ -33,7 +33,6 @@ use serde::Serialize;
     Serialize,
     Deserialize,
     PartialEq,
-    Eq,
     ::rkyv::Archive,
     ::rkyv::Serialize,
     ::rkyv::Deserialize,

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

@@ -17,9 +17,7 @@
 use crate::JValue;
 use crate::RawValue;
 
-use air_interpreter_cid::raw_value_to_json_cid;
 use air_interpreter_cid::value_to_json_cid;
-use air_interpreter_cid::verify_raw_value;
 use air_interpreter_cid::verify_value;
 use air_interpreter_cid::CidCalculationError;
 use air_interpreter_cid::CidRef;
@@ -32,7 +30,7 @@ use thiserror::Error as ThisError;
 use std::{collections::HashMap, rc::Rc};
 
 /// Stores CID to Value corresponance.
-#[derive(Clone, Debug, Serialize, Deserialize, PartialEq, Eq)]
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 #[serde(transparent)]
 #[derive(::rkyv::Archive, ::rkyv::Serialize, ::rkyv::Deserialize)]
 #[archive(check_bytes)]
@@ -87,7 +85,7 @@ impl<Val: Serialize> CidStore<Val> {
 impl CidStore<RawValue> {
     pub fn verify_raw_value(&self) -> Result<(), CidStoreVerificationError> {
         for (cid, value) in &self.0 {
-            verify_raw_value(cid, value.as_inner())?;
+            verify_value(cid, value)?;
         }
         Ok(())
     }
@@ -151,7 +149,7 @@ impl<Val: Serialize> CidTracker<Val> {
 impl CidTracker<RawValue> {
     pub fn track_raw_value(&mut self, value: impl Into<Rc<RawValue>>) -> CID<RawValue> {
         let value = value.into();
-        let cid = raw_value_to_json_cid(value.as_inner());
+        let cid = value_to_json_cid(&*value).expect("TODO refcator");
         self.cids.insert(cid.clone(), value);
         cid
     }

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

@@ -19,40 +19,22 @@ use crate::JValue;
 use serde::Deserialize;
 use serde::Serialize;
 
-use std::cell::RefCell;
-
-#[derive(Serialize, Deserialize, Debug, Clone)]
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq)]
 #[serde(transparent)]
 #[derive(::rkyv::Archive, ::rkyv::Serialize, ::rkyv::Deserialize)]
 #[archive(check_bytes)]
 pub struct RawValue {
-    raw: Box<str>,
-
-    #[serde(skip)]
-    #[with(::rkyv::with::Skip)]
-    parsed: RefCell<Option<JValue>>,
+    value: JValue,
 }
 
 impl RawValue {
     pub fn from_value(value: impl Into<JValue>) -> Self {
         let value = value.into();
-        let raw = value.to_string().into();
-        Self {
-            raw,
-            parsed: Some(value).into(),
-        }
+        Self { value }
     }
 
     pub fn get_value(&self) -> JValue {
-        let mut parsed_guard = self.parsed.borrow_mut();
-
-        let parsed_value = parsed_guard
-            .get_or_insert_with(|| serde_json::from_str(&self.raw).expect("TODO handle error"));
-        parsed_value.clone()
-    }
-
-    pub(crate) fn as_inner(&self) -> &str {
-        &self.raw
+        self.value.clone()
     }
 }
 
@@ -61,12 +43,3 @@ impl From<JValue> for RawValue {
         Self::from_value(value)
     }
 }
-
-impl PartialEq for RawValue {
-    fn eq(&self, other: &Self) -> bool {
-        self.get_value() == other.get_value()
-    }
-}
-
-// TODO is it implemented for JValue?
-impl Eq for RawValue {}