fix(supervisor): error consistency

crates/supervisor/core/src/error.rs

@@ -123,9 +123,7 @@ impl From<StorageError> for SpecError {
                 Self::from(SuperchainDAError::UninitializedChainDatabase)
             }
             StorageError::ConflictError => Self::from(SuperchainDAError::ConflictingData),
-            StorageError::BlockOutOfOrder | StorageError::DerivedBlockOutOfOrder => {
-                Self::from(SuperchainDAError::OutOfOrder)
-            }
+            StorageError::BlockOutOfOrder => Self::from(SuperchainDAError::OutOfOrder),
             _ => Self::ErrorNotInSpec,
         }
     }
@@ -151,7 +149,7 @@ mod test {
 
         assert_eq!(spec_err, expected_err.into());
 
-        let spec_err = ErrorObjectOwned::from(SpecError::from(StorageError::InvalidAnchor));
+        let spec_err = ErrorObjectOwned::from(SpecError::from(StorageError::LockPoisoned));
         let expected_err = SpecError::ErrorNotInSpec;
 
         assert_eq!(spec_err, expected_err.into());
@@ -173,7 +171,7 @@ mod test {
     fn test_supervisor_error_conversion() {
         // This will happen implicitly in server rpc response calls.
         let supervisor_err = ErrorObjectOwned::from(SupervisorError::SpecError(SpecError::from(
-            StorageError::InvalidAnchor,
+            StorageError::LockPoisoned,
         )));
         let expected_err = SpecError::ErrorNotInSpec;
 

crates/supervisor/storage/src/error.rs

@@ -26,10 +26,6 @@ pub enum StorageError {
     #[error("data not yet available")]
     FutureData,
 
-    /// Represents an error that occurred while initializing the database with an anchor.
-    #[error("invalid anchor")]
-    InvalidAnchor,
-
     /// Represents an error that occurred when database is not initialized.
     #[error("database not initialized")]
     DatabaseNotInitialised,
@@ -41,10 +37,6 @@ pub enum StorageError {
     /// Represents an error that occurred while writing to log database.
     #[error("latest stored block is not parent of the incoming block")]
     BlockOutOfOrder,
-
-    /// Represents an error that occurred while writing to derived block database.
-    #[error("latest stored derived block is not parent of the incoming derived block")]
-    DerivedBlockOutOfOrder,
 }
 
 impl PartialEq for StorageError {
@@ -54,9 +46,9 @@ impl PartialEq for StorageError {
             (Database(a), Database(b)) => a == b,
             (DatabaseInit(a), DatabaseInit(b)) => format!("{}", a) == format!("{}", b),
             (EntryNotFound(a), EntryNotFound(b)) => a == b,
-            (InvalidAnchor, InvalidAnchor) |
-            (DatabaseNotInitialised, DatabaseNotInitialised) |
-            (ConflictError, ConflictError) => true,
+            (DatabaseNotInitialised, DatabaseNotInitialised) | (ConflictError, ConflictError) => {
+                true
+            }
             _ => false,
         }
     }

crates/supervisor/storage/src/providers/derivation_provider.rs

@@ -75,9 +75,7 @@ where
               actual_hash = %derived_block_pair.derived.hash,
               "Derived block hash mismatch"
             );
-            return Err(StorageError::EntryNotFound(
-                "derived block hash does not match".to_string(),
-            ));
+            return Err(StorageError::ConflictError);
         }
 
         Ok(derived_block_pair)
@@ -144,7 +142,7 @@ where
                 source_block_hash = %source_block_id.hash,
                 "Source block hash mismatch"
             );
-            return Err(StorageError::EntryNotFound("source block hash mismatch".to_string()));
+            return Err(StorageError::ConflictError);
         }
 
         while block_traversal.derived_block_numbers.is_empty() {
@@ -239,20 +237,17 @@ impl<TX> DerivationProvider<'_, TX>
 where
     TX: DbTxMut + DbTx,
 {
-    /// initialises the database with a derived block pair anchor.
-    pub(crate) fn initialise(&self, anchor: DerivedRefPair) -> Result<(), StorageError> {
+    /// initialises the database with a derived activation block pair.
+    pub(crate) fn initialise(&self, activation_pair: DerivedRefPair) -> Result<(), StorageError> {
         match self.get_derived_block_pair_by_number(0) {
-            Ok(pair)
-                if pair.derived.hash == anchor.derived.hash &&
-                    pair.source.hash == anchor.source.hash =>
-            {
+            Ok(pair) if activation_pair == pair.clone().into() => {
                 // Anchor matches, nothing to do
                 Ok(())
             }
-            Ok(_) => Err(StorageError::InvalidAnchor),
+            Ok(_) => Err(StorageError::ConflictError),
             Err(StorageError::EntryNotFound(_)) => {
-                self.save_source_block_internal(anchor.source)?;
-                self.save_derived_block_internal(anchor)?;
+                self.save_source_block_internal(activation_pair.source)?;
+                self.save_derived_block_internal(activation_pair)?;
                 Ok(())
             }
             Err(err) => Err(err),
@@ -319,7 +314,7 @@ where
               incoming_derived_block_pair = %incoming_pair,
               "Latest stored derived block is not parent of the incoming derived block"
             );
-            return Err(StorageError::DerivedBlockOutOfOrder);
+            return Err(StorageError::BlockOutOfOrder);
         }
 
         self.save_derived_block_internal(incoming_pair)
@@ -572,7 +567,7 @@ mod tests {
         let wrong_derived = block_info(0, B256::from([42u8; 32]), 200);
         let wrong_anchor = derived_pair(source, wrong_derived);
 
-        let result = insert_pair(&db, &wrong_anchor);
+        let result = initialize_db(&db, &wrong_anchor);
         assert!(matches!(result, Err(StorageError::ConflictError)));
     }
 
@@ -609,7 +604,7 @@ mod tests {
         let derived2 = block_info(2, wrong_parent_hash, 300);
         let pair2 = derived_pair(source1, derived2);
         let result = insert_pair(&db, &pair2);
-        assert!(matches!(result, Err(StorageError::DerivedBlockOutOfOrder)));
+        assert!(matches!(result, Err(StorageError::BlockOutOfOrder)));
     }
 
     #[test]
@@ -624,7 +619,7 @@ mod tests {
         let derived2 = block_info(4, derived1.hash, 400); // should be 2, not 4
         let pair2 = derived_pair(source1, derived2);
         let result = insert_pair(&db, &pair2);
-        assert!(matches!(result, Err(StorageError::DerivedBlockOutOfOrder)));
+        assert!(matches!(result, Err(StorageError::BlockOutOfOrder)));
     }
 
     #[test]
@@ -739,7 +734,7 @@ mod tests {
         let wrong_hash = B256::from([123u8; 32]);
         let source_id = BlockNumHash { number: source1.number, hash: wrong_hash };
         let result = provider.latest_derived_block_at_source(source_id);
-        assert!(matches!(result, Err(StorageError::EntryNotFound(_))));
+        assert!(matches!(result, Err(StorageError::ConflictError)));
     }
 
     #[test]

crates/supervisor/storage/src/providers/log_provider.rs

@@ -43,12 +43,12 @@ impl<TX> LogProvider<'_, TX>
 where
     TX: DbTxMut + DbTx,
 {
-    pub(crate) fn initialise(&self, anchor: BlockInfo) -> Result<(), StorageError> {
+    pub(crate) fn initialise(&self, activation_block: BlockInfo) -> Result<(), StorageError> {
         match self.get_block(0) {
-            Ok(block) if block.hash == anchor.hash => Ok(()),
-            Ok(_) => Err(StorageError::InvalidAnchor),
+            Ok(block) if block == activation_block => Ok(()),
+            Ok(_) => Err(StorageError::ConflictError),
             Err(StorageError::EntryNotFound(_)) => {
-                self.store_block_logs_internal(&anchor, Vec::new())
+                self.store_block_logs_internal(&activation_block, Vec::new())
             }
 
             Err(err) => Err(err),
@@ -363,7 +363,7 @@ mod tests {
         wrong_genesis.hash = B256::from([42u8; 32]);
 
         let result = initialize_db(&db, &wrong_genesis);
-        assert!(matches!(result, Err(StorageError::InvalidAnchor)));
+        assert!(matches!(result, Err(StorageError::ConflictError)));
     }
 
     #[test]