Support either Finality or Optimistic verification

contracts/light-client/src/contract.rs

@@ -46,7 +46,7 @@ pub fn execute(
             let config = CONFIG.load(deps.storage)?;
             let lc = LightClient::new(&config.chain_config, Some(state), &env);
 
-            let results = process_batch_data(deps, &lc, &payload)
+            let results = process_batch_data(deps, &lc, &payload, &config)
                 .map_err(|e| ContractError::Std(StdError::GenericErr { msg: e.to_string() }))?;
 
             Ok(Response::new().set_data(to_json_binary(
@@ -166,7 +166,7 @@ mod tests {
 
         let mut lc = LightClient::new(&get_config().chain_config, None, &env);
         lc.bootstrap(&bootstrap).unwrap();
-        assert_eq!(state, lc.state)
+        assert_eq!(state, lc.state);
     }
 
     #[test]

contracts/light-client/src/execute.rs

@@ -2,7 +2,7 @@ use crate::ContractError;
 use cosmwasm_std::{DepsMut, Env, Response};
 use eyre::{eyre, Result};
 use hasher::{Hasher, HasherKeccak};
-use types::common::PrimaryKey;
+use types::common::{Config, FinalizationVariant, PrimaryKey};
 use types::consensus::BeaconBlockHeader;
 use types::execution::ReceiptLogs;
 use types::proofs::{
@@ -134,13 +134,28 @@ pub fn process_batch_data(
     deps: DepsMut,
     lightclient: &LightClient,
     data: &BatchVerificationData,
+    config: &Config,
 ) -> Result<Vec<(ContentVariant, Result<()>)>> {
     match &data.update {
-        UpdateVariant::Finality(update) => lightclient.verify_finality_update(update)?,
-        UpdateVariant::Optimistic(update) => lightclient.verify_optimistic_update(update)?,
+        UpdateVariant::Finality(update) => {
+            if matches!(config.finalization, FinalizationVariant::Optimistic()) {
+                return Err(eyre!(
+                    "Optimistic verification enabled but provided Finality update"
+                ));
+            }
+            lightclient.verify_finality_update(update)?
+        }
+        UpdateVariant::Optimistic(update) => {
+            if matches!(config.finalization, FinalizationVariant::Finality()) {
+                return Err(eyre!(
+                    "Finality verification enabled but provided Optimistic update"
+                ));
+            }
+            lightclient.verify_optimistic_update(update)?
+        }
     }
     let recent_block = data.update.recent_block();
-    let gateway_address = CONFIG.load(deps.storage)?.gateway_address;
+    let gateway_address = config.gateway_address.clone();
 
     let results = data
         .target_blocks
@@ -197,7 +212,7 @@ pub mod tests {
     use cosmwasm_std::testing::mock_dependencies;
     use eyre::Result;
     use types::alloy_primitives::Address;
-    use types::common::{ContentVariant, PrimaryKey, WorkerSetMessage};
+    use types::common::{ContentVariant, FinalizationVariant, PrimaryKey, WorkerSetMessage};
     use types::consensus::{FinalityUpdate, OptimisticUpdate};
     use types::execution::{ReceiptLog, ReceiptLogs};
     use types::proofs::{
@@ -520,10 +535,16 @@ pub mod tests {
             for finalization in ["finality", "optimistic"] {
                 let (bootstrap, mut data) = get_batched_data(historical, finalization);
                 let lc = init_lightclient(Some(bootstrap));
+                let mut config = get_config();
+                config.finalization = match finalization {
+                    "finality" => FinalizationVariant::Finality(),
+                    "optimistic" => FinalizationVariant::Optimistic(),
+                    _ => config.finalization,
+                };
                 let mut deps = mock_dependencies();
                 CONFIG.save(&mut deps.storage, &get_config()).unwrap();
 
-                let res = process_batch_data(deps.as_mut(), &lc, &data);
+                let res = process_batch_data(deps.as_mut(), &lc, &data, &config);
                 let contents = data
                     .target_blocks
                     .iter()
@@ -546,6 +567,15 @@ pub mod tests {
                     }
                 }
 
+                // finalization type of update is different than config
+                let mut corrupt_config = config.clone();
+                corrupt_config.finalization = match finalization {
+                    "finality" => FinalizationVariant::Optimistic(),
+                    "optimistic" => FinalizationVariant::Finality(),
+                    _ => corrupt_config.finalization,
+                };
+                assert!(process_batch_data(deps.as_mut(), &lc, &data, &corrupt_config).is_err());
+
                 // Corrupt the update
                 let mut corrupt_data = data.clone();
                 match finalization {
@@ -557,7 +587,7 @@ pub mod tests {
                     }
                     _ => panic!("Unknown finalization"),
                 };
-                assert!(process_batch_data(deps.as_mut(), &lc, &corrupt_data).is_err());
+                assert!(process_batch_data(deps.as_mut(), &lc, &corrupt_data, &config).is_err(),);
 
                 // Corrupt the contents
                 for target_block in data.target_blocks.iter_mut() {
@@ -568,7 +598,7 @@ pub mod tests {
                     .iter()
                     .flat_map(|target_block| extract_content_from_block(target_block))
                     .collect::<Vec<ContentVariant>>();
-                let res = process_batch_data(deps.as_mut(), &lc, &data);
+                let res = process_batch_data(deps.as_mut(), &lc, &data, &config);
                 assert!(res.is_ok());
                 assert_invalid_contents(&contents, &res.unwrap());
             }

contracts/light-client/src/lightclient/helpers.rs

@@ -402,7 +402,7 @@ pub mod test_helpers {
     use ethabi::{decode, ParamType};
     use std::fs::File;
 
-    use types::common::{Config, WorkerSetMessage};
+    use types::common::{Config, FinalizationVariant, WorkerSetMessage};
     use types::connection_router::state::Message;
     use types::execution::ReceiptLog;
     use types::proofs::{
@@ -480,6 +480,7 @@ pub mod test_helpers {
                 genesis_root: Node::from_bytes(genesis_root_bytes),
             },
             gateway_address: String::from("0x4F4495243837681061C4743b74B3eEdf548D56A5"),
+            finalization: FinalizationVariant::Finality(),
         }
     }
 

contracts/light-client/testdata/instantiate.json

@@ -1,8 +1,12 @@
 {
   "config": {
-    "chain_id": 1,
-    "genesis_time": 1606824023,
-    "genesis_root": "0x4b363db94e286120d76eb905340fdd4e54bfe9f06bf33ff6cf5ad27f511bfe95",
+    "chain_config": {
+      "chain_id": 1,
+      "genesis_time": 1606824023,
+      "genesis_root": "0x4b363db94e286120d76eb905340fdd4e54bfe9f06bf33ff6cf5ad27f511bfe95"
+    },
+    "gateway_address": "",
+    "finalization": {"Finality": []}
   },
   "bootstrap": {
     "header": {

types/src/common.rs

@@ -17,10 +17,17 @@ pub struct ChainConfig {
     pub genesis_root: Node,
 }
 
+#[derive(serde::Serialize, serde::Deserialize, Clone, Debug, PartialEq)]
+pub enum FinalizationVariant {
+    Optimistic(),
+    Finality(),
+}
+
 #[derive(serde::Serialize, serde::Deserialize, Clone, Debug, PartialEq)]
 pub struct Config {
     pub chain_config: ChainConfig,
     pub gateway_address: String,
+    pub finalization: FinalizationVariant,
 }
 
 /// Message describing an update of the operators set