feat: Add ReportDataV7 schema

Author: andrejrakic

rust/crates/report/src/report.rs

@@ -6,6 +6,7 @@ pub mod v3;
 pub mod v4;
 pub mod v5;
 pub mod v6;
+pub mod v7;
 pub mod v8;
 pub mod v9;
 pub mod v10;
@@ -122,7 +123,7 @@ pub fn decode_full_report(payload: &[u8]) -> Result<(Vec<[u8; 32]>, Vec<u8>), Re
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::report::{v1::ReportDataV1, v2::ReportDataV2, v3::ReportDataV3, v4::ReportDataV4, v5::ReportDataV5, v6::ReportDataV6, v8::ReportDataV8, v9::ReportDataV9, v10::ReportDataV10};
+    use crate::report::{v1::ReportDataV1, v2::ReportDataV2, v3::ReportDataV3, v4::ReportDataV4, v5::ReportDataV5, v6::ReportDataV6, v7::ReportDataV7, v8::ReportDataV8, v9::ReportDataV9, v10::ReportDataV10};
     use num_bigint::BigInt;
 
     const V1_FEED_ID: ID = ID([
@@ -149,6 +150,10 @@ mod tests {
         00, 06, 107, 74, 167, 229, 124, 167, 182, 138, 225, 191, 69, 101, 63, 86, 182, 86, 253, 58,
         163, 53, 239, 127, 174, 105, 107, 102, 63, 27, 132, 114,
     ]);
+    const V7_FEED_ID: ID = ID([
+        00, 07, 107, 74, 167, 229, 124, 167, 182, 138, 225, 191, 69, 101, 63, 86, 182, 86, 253, 58,
+        163, 53, 239, 127, 174, 105, 107, 102, 63, 27, 132, 114,
+    ]);
     const V8_FEED_ID: ID = ID([
         00, 08, 107, 74, 167, 229, 124, 167, 182, 138, 225, 191, 69, 101, 63, 86, 182, 86, 253, 58,
         163, 53, 239, 127, 174, 105, 107, 102, 63, 27, 132, 114,
@@ -269,6 +274,20 @@ mod tests {
         report_data
     }
 
+    pub fn generate_mock_report_data_v7() -> ReportDataV7 {
+        let report_data = ReportDataV7 {
+            feed_id: V7_FEED_ID,
+            valid_from_timestamp: MOCK_TIMESTAMP,
+            observations_timestamp: MOCK_TIMESTAMP,
+            native_fee: BigInt::from(MOCK_FEE),
+            link_fee: BigInt::from(MOCK_FEE),
+            expires_at: MOCK_TIMESTAMP + 100,
+            exchange_rate: BigInt::from(MOCK_PRICE),
+        };
+
+        report_data
+    }
+
     pub fn generate_mock_report_data_v8() -> ReportDataV8 {
         let report_data = ReportDataV8 {
             feed_id: V8_FEED_ID,
@@ -551,6 +570,35 @@ mod tests {
         assert_eq!(decoded_report.feed_id, V6_FEED_ID);
     }
 
+    #[test]
+    fn test_decode_report_v7() {
+        let report_data = generate_mock_report_data_v7();
+        let encoded_report_data = report_data.abi_encode().unwrap();
+
+        let report = generate_mock_report(&encoded_report_data);
+
+        let (_report_context, report_blob) = decode_full_report(&report).unwrap();
+
+        let expected_report_blob = vec![
+            "00076b4aa7e57ca7b68ae1bf45653f56b656fd3aa335ef7fae696b663f1b8472",
+            "0000000000000000000000000000000000000000000000000000000066741d8c",
+            "0000000000000000000000000000000000000000000000000000000066741d8c",
+            "000000000000000000000000000000000000000000000000000000000000000a",
+            "000000000000000000000000000000000000000000000000000000000000000a",
+            "0000000000000000000000000000000000000000000000000000000066741df0",
+            "0000000000000000000000000000000000000000000000000000000000000064", // Exchange Rate: 100
+        ];
+
+        assert_eq!(
+            report_blob,
+            bytes(&format!("0x{}", expected_report_blob.join("")))
+        );
+
+        let decoded_report = ReportDataV7::decode(&report_blob).unwrap();
+
+        assert_eq!(decoded_report.feed_id, V7_FEED_ID);
+    }
+
     #[test]
     fn test_decode_report_v8() {
         let report_data = generate_mock_report_data_v8();

rust/crates/report/src/report/v7.rs

@@ -0,0 +1,134 @@
+use crate::feed_id::ID;
+use crate::report::base::{ReportBase, ReportError};
+
+use num_bigint::BigInt;
+
+/// Represents a Report Data V7 Schema.
+///
+/// # Parameters
+/// - `feed_id`: The feed ID the report has data for.
+/// - `valid_from_timestamp`: Earliest timestamp for which price is applicable.
+/// - `observations_timestamp`: Latest timestamp for which price is applicable.
+/// - `native_fee`: Base cost to validate a transaction using the report, denominated in the chain's native token (e.g., WETH/ETH).
+/// - `link_fee`: Base cost to validate a transaction using the report, denominated in LINK.
+/// - `expires_at`: Latest timestamp where the report can be verified onchain.
+/// - `exchange_rate`: The exchange rate.
+///
+/// # Solidity Equivalent
+/// ```solidity
+/// struct ReportDataV7 {
+///     bytes32 feedId;
+///     uint32 validFromTimestamp;
+///     uint32 observationsTimestamp;
+///     uint192 nativeFee;
+///     uint192 linkFee;
+///     uint32 expiresAt;
+///     int192 exchangeRate;
+/// }
+/// ```
+#[derive(Debug)]
+pub struct ReportDataV7 {
+    pub feed_id: ID,
+    pub valid_from_timestamp: u32,
+    pub observations_timestamp: u32,
+    pub native_fee: BigInt,
+    pub link_fee: BigInt,
+    pub expires_at: u32,
+    pub exchange_rate: BigInt,
+}
+
+impl ReportDataV7 {
+    /// Decodes an ABI-encoded `ReportDataV7` from bytes.
+    ///
+    /// # Parameters
+    ///
+    /// - `data`: The encoded report data.
+    ///
+    /// # Returns
+    ///
+    /// The decoded `ReportDataV7`.
+    ///
+    /// # Errors
+    ///
+    /// Returns a `ReportError` if the data is too short or if the data is invalid.
+    pub fn decode(data: &[u8]) -> Result<Self, ReportError> {
+        if data.len() < 7 * ReportBase::WORD_SIZE {
+            return Err(ReportError::DataTooShort("ReportDataV7"));
+        }
+
+        let feed_id = ID(data[..ReportBase::WORD_SIZE]
+            .try_into()
+            .map_err(|_| ReportError::InvalidLength("feed_id (bytes32)"))?);
+
+        let valid_from_timestamp = ReportBase::read_uint32(data, ReportBase::WORD_SIZE)?;
+        let observations_timestamp = ReportBase::read_uint32(data, 2 * ReportBase::WORD_SIZE)?;
+        let native_fee = ReportBase::read_uint192(data, 3 * ReportBase::WORD_SIZE)?;
+        let link_fee = ReportBase::read_uint192(data, 4 * ReportBase::WORD_SIZE)?;
+        let expires_at = ReportBase::read_uint32(data, 5 * ReportBase::WORD_SIZE)?;
+        let exchange_rate = ReportBase::read_int192(data, 6 * ReportBase::WORD_SIZE)?;
+
+        Ok(Self {
+            feed_id,
+            valid_from_timestamp,
+            observations_timestamp,
+            native_fee,
+            link_fee,
+            expires_at,
+            exchange_rate,
+        })
+    }
+
+    /// Encodes the `ReportDataV7` into an ABI-encoded byte array.
+    ///
+    /// # Returns
+    ///
+    /// The ABI-encoded report data.
+    ///
+    /// # Errors
+    ///
+    /// Returns a `ReportError` if the data is invalid.
+    pub fn abi_encode(&self) -> Result<Vec<u8>, ReportError> {
+        let mut buffer = Vec::with_capacity(7 * ReportBase::WORD_SIZE);
+
+        buffer.extend_from_slice(&self.feed_id.0);
+        buffer.extend_from_slice(&ReportBase::encode_uint32(self.valid_from_timestamp)?);
+        buffer.extend_from_slice(&ReportBase::encode_uint32(self.observations_timestamp)?);
+        buffer.extend_from_slice(&ReportBase::encode_uint192(&self.native_fee)?);
+        buffer.extend_from_slice(&ReportBase::encode_uint192(&self.link_fee)?);
+        buffer.extend_from_slice(&ReportBase::encode_uint32(self.expires_at)?);
+        buffer.extend_from_slice(&ReportBase::encode_int192(&self.exchange_rate)?);
+
+        Ok(buffer)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::report::tests::{
+        generate_mock_report_data_v7, MOCK_FEE, MOCK_PRICE, MOCK_TIMESTAMP,
+    };
+
+    const V7_FEED_ID_STR: &str =
+        "0x00076b4aa7e57ca7b68ae1bf45653f56b656fd3aa335ef7fae696b663f1b8472";
+
+    #[test]
+    fn test_decode_report_data_v7() {
+        let report_data = generate_mock_report_data_v7();
+        let encoded = report_data.abi_encode().unwrap();
+        let decoded = ReportDataV7::decode(&encoded).unwrap();
+
+        let expected_feed_id = ID::from_hex_str(V7_FEED_ID_STR).unwrap();
+        let expected_timestamp: u32 = MOCK_TIMESTAMP;
+        let expected_fee = BigInt::from(MOCK_FEE);
+        let expected_exchange_rate = BigInt::from(MOCK_PRICE);
+
+        assert_eq!(decoded.feed_id, expected_feed_id);
+        assert_eq!(decoded.valid_from_timestamp, expected_timestamp);
+        assert_eq!(decoded.observations_timestamp, expected_timestamp);
+        assert_eq!(decoded.native_fee, expected_fee);
+        assert_eq!(decoded.link_fee, expected_fee);
+        assert_eq!(decoded.expires_at, expected_timestamp + 100);
+        assert_eq!(decoded.exchange_rate, expected_exchange_rate);
+    }
+}