fix(repo): Serializing block time as integer

Author: pedronauck

.github/actions/setup-rust/action.yaml

@@ -64,7 +64,7 @@ runs:
 
     - name: Run sccache-cache only on non-release runs
       if: inputs.cache == 'true' || github.event_name != 'release' || github.event_name != 'workflow_dispatch'
-      uses: mozilla-actions/sccache-action@v0.0.5
+      uses: mozilla-actions/sccache-action@v0.0.8
 
     - name: Set Rust caching env vars only on non-release runs
       shell: sh

crates/types/src/primitives/block_header.rs

@@ -1,18 +1,24 @@
-use std::collections::HashMap;
+use std::{collections::HashMap, fmt};
 
 use apache_avro::{
     schema::{derive::AvroSchemaComponent, Name},
     AvroSchema,
     Schema,
 };
 use chrono::{DateTime, TimeZone, Utc};
-use serde::{Deserialize, Serialize};
+use serde::{
+    de::{self, Deserializer, Visitor},
+    ser::Serializer,
+    Deserialize,
+    Serialize,
+};
 use wrapped_int::WrappedU32;
 
 use crate::*;
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq)]
 pub struct BlockTime(pub FuelCoreTai64);
+
 impl BlockTime {
     pub fn into_inner(self) -> FuelCoreTai64 {
         self.0
@@ -34,6 +40,87 @@ impl Default for BlockTime {
     }
 }
 
+impl Serialize for BlockTime {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let unix_timestamp = self.0.to_unix();
+        serializer.serialize_i64(unix_timestamp)
+    }
+}
+
+impl<'de> Deserialize<'de> for BlockTime {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct BlockTimeVisitor;
+
+        impl<'de> Visitor<'de> for BlockTimeVisitor {
+            type Value = BlockTime;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str(
+                    "a string Unix timestamp or an 8-byte array or an integer",
+                )
+            }
+
+            fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E>
+            where
+                E: de::Error,
+            {
+                Ok(BlockTime(FuelCoreTai64::from_unix(value)))
+            }
+
+            fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
+            where
+                E: de::Error,
+            {
+                Ok(BlockTime(FuelCoreTai64::from_unix(value as i64)))
+            }
+
+            fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+            where
+                E: de::Error,
+            {
+                let unix_timestamp =
+                    value.parse::<i64>().map_err(de::Error::custom)?;
+                Ok(BlockTime(FuelCoreTai64::from_unix(unix_timestamp)))
+            }
+
+            fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
+            where
+                E: de::Error,
+            {
+                let tai64 = FuelCoreTai64::from_slice(value).map_err(|_| {
+                    de::Error::custom("expected an 8-byte array for TAI64")
+                })?;
+                Ok(BlockTime(tai64))
+            }
+
+            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+            where
+                A: de::SeqAccess<'de>,
+            {
+                let mut bytes = [0u8; 8];
+                for byte in &mut bytes {
+                    *byte = seq.next_element()?.ok_or_else(|| {
+                        de::Error::custom("byte array too short")
+                    })?;
+                }
+                if seq.next_element::<u8>()?.is_some() {
+                    return Err(de::Error::custom("byte array too long"));
+                }
+                let tai64 = FuelCoreTai64::from(bytes);
+                Ok(BlockTime(tai64))
+            }
+        }
+
+        deserializer.deserialize_any(BlockTimeVisitor)
+    }
+}
+
 impl utoipa::ToSchema for BlockTime {
     fn name() -> std::borrow::Cow<'static, str> {
         std::borrow::Cow::Borrowed("BlockTime")
@@ -63,12 +150,10 @@ impl AvroSchemaComponent for BlockTime {
         _ctxt: &mut HashMap<Name, Schema>,
         _namespace: &Option<String>,
     ) -> Schema {
-        // Use Avro's `long` type (i64) for serialization
         Schema::Long
     }
 }
 
-// Header type
 #[derive(
     Debug,
     Clone,
@@ -135,7 +220,6 @@ impl From<&FuelCoreBlockHeader> for BlockHeader {
     }
 }
 
-// BlockHeaderVersion enum
 #[derive(
     Debug,
     Clone,
@@ -147,9 +231,90 @@ impl From<&FuelCoreBlockHeader> for BlockHeader {
     derive_more::Display,
     apache_avro::AvroSchema,
 )]
-#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
+#[serde(rename_all = "snake_case")]
 pub enum BlockHeaderVersion {
     #[default]
     #[display("V1")]
     V1,
 }
+
+#[cfg(test)]
+mod tests {
+    use pretty_assertions::assert_eq;
+    use serde_json;
+
+    use super::*;
+
+    #[test]
+    fn test_serialize_string() {
+        let block_time = BlockTime::from_unix(1614556800);
+        let serialized = serde_json::to_string(&block_time).unwrap();
+        assert_eq!(serialized, "1614556800"); // Expect integer
+    }
+
+    #[test]
+    fn test_deserialize_string() {
+        let json = "\"1614556800\"";
+        let deserialized: BlockTime = serde_json::from_str(json).unwrap();
+        let expected = BlockTime::from_unix(1614556800);
+        assert_eq!(deserialized, expected);
+        assert_eq!(deserialized.0.to_unix(), 1614556800);
+    }
+
+    #[test]
+    fn test_deserialize_byte_array() {
+        let block_time = BlockTime::from_unix(1614556800);
+        let bytes = block_time.0.to_bytes();
+        let json = serde_json::to_string(&bytes.to_vec()).unwrap();
+        let deserialized: BlockTime = serde_json::from_str(&json).unwrap();
+        assert_eq!(deserialized, block_time);
+        assert_eq!(deserialized.0.to_unix(), 1614556800);
+    }
+
+    #[test]
+    fn test_round_trip_string() {
+        let original = BlockTime::from_unix(1614556800);
+        let serialized = serde_json::to_string(&original).unwrap();
+        let deserialized: BlockTime =
+            serde_json::from_str(&serialized).unwrap();
+        assert_eq!(deserialized, original);
+    }
+
+    #[test]
+    fn test_deserialize_invalid_string() {
+        let json = "\"not-a-number\"";
+        let result = serde_json::from_str::<BlockTime>(json);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_deserialize_invalid_byte_array_length() {
+        let json = "[1, 2, 3]";
+        let result = serde_json::from_str::<BlockTime>(json);
+        assert!(result.is_err());
+
+        let json = "[1, 2, 3, 4, 5, 6, 7, 8, 9]";
+        let result = serde_json::from_str::<BlockTime>(json);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_get_timestamp_utc() {
+        let block_time = BlockTime::from_unix(1614556800);
+        let header = BlockHeader {
+            time: block_time,
+            ..Default::default()
+        };
+        let utc_time = header.get_timestamp_utc();
+        assert_eq!(utc_time.to_rfc3339(), "2021-03-01T00:00:00+00:00");
+    }
+
+    #[test]
+    fn test_deserialize_integer() {
+        let json = "1614556800";
+        let deserialized: BlockTime = serde_json::from_str(json).unwrap();
+        let expected = BlockTime::from_unix(1614556800);
+        assert_eq!(deserialized, expected);
+        assert_eq!(deserialized.0.to_unix(), 1614556800);
+    }
+}

scripts/subjects-schema/src/main.rs

@@ -4,6 +4,7 @@ use fuel_streams_domains::{
     blocks::subjects::*,
     inputs::subjects::*,
     outputs::subjects::*,
+    predicates::PredicatesSubject,
     receipts::subjects::*,
     transactions::subjects::*,
     utxos::subjects::*,
@@ -39,6 +40,8 @@ fn main() {
         outputs_contract_created_schema,
     );
 
+    let predicates_schema = PredicatesSubject::new().schema();
+
     let mut receipts_schema = ReceiptsSubject::new().schema();
     let receipts_call_schema = ReceiptsCallSubject::new().schema();
     let receipts_return_schema = ReceiptsReturnSubject::new().schema();
@@ -82,6 +85,7 @@ fn main() {
         ("transactions".to_string(), transaction_schema),
         ("inputs".to_string(), inputs_schema),
         ("outputs".to_string(), outputs_schema),
+        ("predicates".to_string(), predicates_schema),
         ("receipts".to_string(), receipts_schema),
         ("utxos".to_string(), utxos_schema),
     ]);