fix(lazer): expose dynamic_value protobuf as rust module, move type to protocol

Author: Riateche

Cargo.lock

@@ -6,27 +6,11 @@ use std::collections::BTreeMap;
 use crate::protobuf::dynamic_value::{dynamic_value, DynamicValue as ProtobufDynamicValue};
 use ::protobuf::MessageField;
 use anyhow::{ensure, Context};
-use derive_more::From;
-use pyth_lazer_protocol::time::{DurationUs, TimestampUs};
-use serde::{
-    ser::{SerializeMap, SerializeSeq},
-    Serialize,
+use pyth_lazer_protocol::{
+    time::{DurationUs, TimestampUs},
+    DynamicValue,
 };
 
-#[derive(Debug, Clone, PartialEq, From)]
-pub enum DynamicValue {
-    String(String),
-    F64(f64),
-    U64(u64),
-    I64(i64),
-    Bool(bool),
-    Timestamp(TimestampUs),
-    Duration(DurationUs),
-    Bytes(Vec<u8>),
-    List(Vec<DynamicValue>),
-    Map(BTreeMap<String, DynamicValue>),
-}
-
 impl From<DynamicValue> for ProtobufDynamicValue {
     fn from(value: DynamicValue) -> Self {
         let converted = match value {
@@ -192,37 +176,3 @@ impl TryFrom<dynamic_value::List> for Vec<DynamicValue> {
         Ok(output)
     }
 }
-
-impl Serialize for DynamicValue {
-    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        match self {
-            DynamicValue::String(v) => serializer.serialize_str(v),
-            DynamicValue::F64(v) => serializer.serialize_f64(*v),
-            DynamicValue::U64(v) => serializer.serialize_u64(*v),
-            DynamicValue::I64(v) => serializer.serialize_i64(*v),
-            DynamicValue::Bool(v) => serializer.serialize_bool(*v),
-            DynamicValue::Timestamp(v) => serializer.serialize_u64(v.as_micros()),
-            DynamicValue::Duration(v) => {
-                serializer.serialize_str(&humantime::format_duration((*v).into()).to_string())
-            }
-            DynamicValue::Bytes(v) => serializer.serialize_str(&hex::encode(v)),
-            DynamicValue::List(v) => {
-                let mut seq_serializer = serializer.serialize_seq(Some(v.len()))?;
-                for element in v {
-                    seq_serializer.serialize_element(element)?;
-                }
-                seq_serializer.end()
-            }
-            DynamicValue::Map(map) => {
-                let mut map_serializer = serializer.serialize_map(Some(map.len()))?;
-                for (k, v) in map {
-                    map_serializer.serialize_entry(k, v)?;
-                }
-                map_serializer.end()
-            }
-        }
-    }
-}

lazer/publisher_sdk/rust/src/dynamic_value.rs renamed to lazer/publisher_sdk/rust/src/convert_dynamic_value.rs

@@ -4,13 +4,11 @@ use protobuf::{
     well_known_types::{duration::Duration, timestamp::Timestamp},
     MessageField,
 };
+use pyth_lazer_protocol::DynamicValue;
 
-use crate::{
-    protobuf::dynamic_value::{
-        dynamic_value::{List, Map, MapItem, Value},
-        DynamicValue as ProtobufDynamicValue,
-    },
-    DynamicValue,
+use crate::protobuf::dynamic_value::{
+    dynamic_value::{List, Map, MapItem, Value},
+    DynamicValue as ProtobufDynamicValue,
 };
 
 #[test]

lazer/publisher_sdk/rust/src/dynamic_value/tests.rs renamed to lazer/publisher_sdk/rust/src/convert_dynamic_value/tests.rs

@@ -25,14 +25,16 @@ pub mod state {
     pub use crate::protobuf::state::*;
 }
 
+pub mod dynamic_value {
+    pub use crate::protobuf::dynamic_value::*;
+}
+
 #[allow(rustdoc::broken_intra_doc_links)]
 mod protobuf {
     include!(concat!(env!("OUT_DIR"), "/protobuf/mod.rs"));
 }
 
-mod dynamic_value;
-
-pub use crate::dynamic_value::DynamicValue;
+mod convert_dynamic_value;
 
 impl From<FeedUpdateParams> for FeedUpdate {
     fn from(value: FeedUpdateParams) -> Self {

lazer/publisher_sdk/rust/src/lib.rs

@@ -18,6 +18,8 @@ protobuf = "3.7.2"
 humantime-serde = "1.1.1"
 mry = { version = "0.13.0", features = ["serde"], optional = true }
 chrono = "0.4.41"
+humantime = "2.2.0"
+hex = "0.4.3"
 
 [dev-dependencies]
 bincode = "1.3.3"

lazer/sdk/rust/protocol/Cargo.toml

@@ -0,0 +1,56 @@
+use std::collections::BTreeMap;
+
+use crate::time::{DurationUs, TimestampUs};
+use derive_more::From;
+use serde::{
+    ser::{SerializeMap, SerializeSeq},
+    Serialize,
+};
+
+#[derive(Debug, Clone, PartialEq, From)]
+pub enum DynamicValue {
+    String(String),
+    F64(f64),
+    U64(u64),
+    I64(i64),
+    Bool(bool),
+    Timestamp(TimestampUs),
+    Duration(DurationUs),
+    Bytes(Vec<u8>),
+    List(Vec<DynamicValue>),
+    Map(BTreeMap<String, DynamicValue>),
+}
+
+impl Serialize for DynamicValue {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        match self {
+            DynamicValue::String(v) => serializer.serialize_str(v),
+            DynamicValue::F64(v) => serializer.serialize_f64(*v),
+            DynamicValue::U64(v) => serializer.serialize_u64(*v),
+            DynamicValue::I64(v) => serializer.serialize_i64(*v),
+            DynamicValue::Bool(v) => serializer.serialize_bool(*v),
+            DynamicValue::Timestamp(v) => serializer.serialize_u64(v.as_micros()),
+            DynamicValue::Duration(v) => {
+                serializer.serialize_str(&humantime::format_duration((*v).into()).to_string())
+            }
+            DynamicValue::Bytes(v) => serializer.serialize_str(&hex::encode(v)),
+            DynamicValue::List(v) => {
+                let mut seq_serializer = serializer.serialize_seq(Some(v.len()))?;
+                for element in v {
+                    seq_serializer.serialize_element(element)?;
+                }
+                seq_serializer.end()
+            }
+            DynamicValue::Map(map) => {
+                let mut map_serializer = serializer.serialize_map(Some(map.len()))?;
+                for (k, v) in map {
+                    map_serializer.serialize_entry(k, v)?;
+                }
+                map_serializer.end()
+            }
+        }
+    }
+}

lazer/sdk/rust/protocol/src/dynamic_value.rs

@@ -2,6 +2,7 @@
 
 pub mod api;
 pub mod binary_update;
+mod dynamic_value;
 mod feed_kind;
 pub mod jrpc;
 pub mod message;
@@ -14,7 +15,7 @@ pub mod subscription;
 pub mod symbol_state;
 pub mod time;
 
-pub use crate::feed_kind::FeedKind;
+pub use crate::{dynamic_value::DynamicValue, feed_kind::FeedKind};
 
 #[test]
 fn magics_in_big_endian() {