Solution (#72): Arithmetic hardening: saturating_add on earnings and next_event_i

path/to/contracts/events/src/errors.rs

@@ -0,0 +1,17 @@
+// Import necessary dependencies
+use std::error::Error;
+
+// Define the Error enum
+#[derive(Debug)]
+pub enum Error {
+    EventIdOverflow,
+}
+
+// Implement the Error trait for the Error enum
+impl std::error::Error for Error {
+    fn description(&self) -> &str {
+        match self {
+            Error::EventIdOverflow => "Event ID overflow",
+        }
+    }
+}

path/to/contracts/events/src/idempotency.rs

@@ -0,0 +1,19 @@
+// Import necessary dependencies
+use std::ops::Add;
+use std::result::Result;
+
+// Define the Error enum
+#[derive(Debug)]
+pub enum Error {
+    EventIdOverflow,
+}
+
+// Modify the next_event_id function to use checked_add and handle overflows
+pub fn next_event_id(current: u64, increment: u64) -> Result<u64, Error> {
+    current.checked_add(increment).ok_or(Error::EventIdOverflow)
+}
+
+// Update the stored_next_event_id function to use checked_add and handle overflows
+pub fn stored_next_event_id(current: u64, increment: u64) -> Result<u64, Error> {
+    current.checked_add(increment).ok_or(Error::EventIdOverflow)
+}

path/to/contracts/events/src/tests/idempotency.rs

@@ -0,0 +1,26 @@
+// Import necessary dependencies
+use super::*;
+
+// Write unit tests to verify that overflows are properly handled and revert with a typed error
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_next_event_id_overflow() {
+        let current = u64::MAX;
+        let increment = 1;
+        let result = next_event_id(current, increment);
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), Error::EventIdOverflow);
+    }
+
+    #[test]
+    fn test_stored_next_event_id_overflow() {
+        let current = u64::MAX;
+        let increment = 1;
+        let result = stored_next_event_id(current, increment);
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), Error::EventIdOverflow);
+    }
+}

path/to/contracts/profile/src/earnings.rs

@@ -0,0 +1,14 @@
+// Import necessary dependencies
+use std::ops::Add;
+use std::result::Result;
+
+// Define the Error enum
+#[derive(Debug)]
+pub enum Error {
+    EarningsOverflow,
+}
+
+// Modify the register function to use checked_add and handle overflows
+pub fn register(current: i128, amount: i128) -> Result<i128, Error> {
+    current.checked_add(amount).ok_or(Error::EarningsOverflow)
+}

path/to/contracts/profile/src/errors.rs

@@ -0,0 +1,17 @@
+// Import necessary dependencies
+use std::error::Error;
+
+// Define the Error enum
+#[derive(Debug)]
+pub enum Error {
+    EarningsOverflow,
+}
+
+// Implement the Error trait for the Error enum
+impl std::error::Error for Error {
+    fn description(&self) -> &str {
+        match self {
+            Error::EarningsOverflow => "Earnings overflow",
+        }
+    }
+}

path/to/contracts/profile/src/tests/earnings.rs

@@ -0,0 +1,17 @@
+// Import necessary dependencies
+use super::*;
+
+// Write unit tests to verify that overflows are properly handled and revert with a typed error
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_register_overflow() {
+        let current = i128::MAX;
+        let amount = 1;
+        let result = register(current, amount);
+        assert!(result.is_err());
+        assert_eq!(result.unwrap_err(), Error::EarningsOverflow);
+    }
+}