fix dat4

Author: Naohiro Yoshida

derivation/src/derivation.rs

@@ -13,14 +13,14 @@ use kona_driver::Driver;
 use kona_executor::TrieDBProvider;
 use kona_genesis::RollupConfig;
 use kona_preimage::{PreimageKey, PreimageOracleClient};
+use kona_proof::boot::L2_ROLLUP_CONFIG_KEY;
 use kona_proof::sync::new_oracle_pipeline_cursor;
 use kona_proof::{
     executor::KonaExecutor,
     l1::{OracleBlobProvider, OracleL1ChainProvider, OraclePipeline},
     l2::OracleL2ChainProvider,
     BootInfo,
 };
-use kona_proof::boot::L2_ROLLUP_CONFIG_KEY;
 use serde::{Deserialize, Serialize};
 
 #[derive(Clone, Debug, Deserialize, Serialize)]
@@ -138,23 +138,67 @@ impl Derivation {
         let header = read.l2_safe_head_header().clone().unseal();
         Ok(header)
     }
-
 }
 
 async fn verify_config(
     rollup_config: &RollupConfig,
     oracle: &MemoryOracleClient,
 ) -> Result<(), Error> {
     let config_key = PreimageKey::new_local(L2_ROLLUP_CONFIG_KEY.to());
-    let local_config = oracle.get(config_key.clone()).await.map_err(|e| Error::UnexpectedPreimageKey {
-        source: e,
-        key: config_key.key_value().to_be_bytes(),
-    })?;
-    let requested = keccak256(local_config);
-    let saved = keccak256(serde_json::to_vec(rollup_config)?);
-    if saved != requested {
-        return Err(Error::InvalidRollupConfig(saved, requested));
+    let in_preimage =
+        oracle
+            .get(config_key.clone())
+            .await
+            .map_err(|e| Error::UnexpectedPreimageKey {
+                source: e,
+                key: config_key.key_value().to_be_bytes(),
+            })?;
+    let in_state = serde_json::to_vec(rollup_config)?;
+    if keccak256(&in_state) != keccak256(&in_preimage) {
+        return Err(Error::InvalidRollupConfig(in_preimage, in_state));
     }
     Ok(())
 }
 
+#[cfg(test)]
+mod test {
+    use crate::derivation::verify_config;
+    use crate::errors::Error;
+    use crate::oracle::MemoryOracleClient;
+    use crate::types::Preimage;
+    use alloc::vec;
+    use kona_genesis::RollupConfig;
+    use kona_preimage::PreimageKey;
+    use kona_proof::boot::L2_ROLLUP_CONFIG_KEY;
+
+    #[test]
+    async fn test_verify_config_not_found_error() {
+        let rollup_config = RollupConfig::default();
+        let oracle = MemoryOracleClient::default();
+        let err = kona_proof::block_on(verify_config(&rollup_config, &oracle)).unwrap_err();
+        match err {
+            Error::UnexpectedPreimageKey { .. } => {}
+            _ => panic!("Unexpected error, got {:?}", err),
+        }
+    }
+
+    #[test]
+    fn test_verify_config_invalid_error() {
+        let rollup_config = RollupConfig::default();
+        let rollup_config2 = RollupConfig {
+            l2_chain_id: rollup_config.l2_chain_id + 1,
+            ..rollup_config.clone()
+        };
+
+        let preimage = vec![Preimage::new(
+            PreimageKey::new_local(L2_ROLLUP_CONFIG_KEY.to()),
+            serde_json::to_vec(&rollup_config2).unwrap(),
+        )];
+        let oracle = MemoryOracleClient::try_from(preimage).unwrap();
+        let err = kona_proof::block_on(verify_config(&rollup_config, &oracle)).unwrap_err();
+        match err {
+            Error::InvalidRollupConfig { .. } => {}
+            _ => panic!("Unexpected error, got {:?}", err),
+        }
+    }
+}

derivation/src/errors.rs

@@ -7,8 +7,8 @@ use kona_preimage::PreimageKey;
 
 #[derive(thiserror::Error, Debug)]
 pub enum Error {
-    #[error("InvalidRollupConfig: saved={0}, requested={1}")]
-    InvalidRollupConfig(B256, B256),
+    #[error("InvalidRollupConfig: in_preimage={0:?}, in_state={1:?}")]
+    InvalidRollupConfig(Vec<u8>, Vec<u8>),
     #[error("InvalidClaim actual={0}, expected={1}")]
     InvalidClaim(B256, B256),
     #[error("UnexpectedKZGCommitment: err={0:?}")]
@@ -53,5 +53,5 @@ pub enum Error {
     #[error("SerdeError: err={0:?}")]
     SerdeError(#[from] serde_json::Error),
     #[error("UnexpectedLocalPreimageKey: key={0:?}")]
-    UnexpectedLocalPreimageKey(PreimageKey)
+    UnexpectedLocalPreimageKey(PreimageKey),
 }

derivation/src/oracle.rs

@@ -308,6 +308,16 @@ mod test {
         }
     }
 
+    #[test]
+    fn test_try_from_invalid_local_key() {
+        let preimage = vec![Preimage::new(PreimageKey::new_local(0), vec![0u8; 10])];
+        let err = MemoryOracleClient::try_from(preimage).unwrap_err();
+        match err {
+            Error::UnexpectedLocalPreimageKey(_) => {}
+            _ => panic!("Unexpected error, got: {:?}", err),
+        }
+    }
+
     #[test]
     fn test_try_from_precompile_error() {
         let preimage = vec![Preimage::new(