feat: admin handler to update config (#98)

## Description
Adds update config admin handler

<!-- Brief description of changes -->

## Checklist

- [ ] I have updated the
[docs/SPEC.md](https://github.com/babylonlabs-io/rollup-bsn-contracts/blob/main/docs/SPEC.md)
file if this change affects the specification
- [ ] I have updated the schema by running `cargo gen-schema`


Note - I will run cargo schema and update spec after all prs are merged,
otherwise it will create git conflict

---------

Co-authored-by: Copilot <[email protected]>

Author: gusin13

CHANGELOG.md

@@ -46,6 +46,8 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/)
 
 * [#91](https://github.com/babylonlabs-io/rollup-bsn-contracts/pull/91) feat:
   optimize public key handling by using bytes instead of hex
+* [#98](https://github.com/babylonlabs-io/rollup-bsn-contracts/pull/98) feat:
+  admin handler to update config
 
 ## v0.1.0
 

contracts/finality/src/contract.rs

@@ -4,6 +4,7 @@ use babylon_bindings::BabylonQuery;
 
 use crate::error::ContractError;
 use crate::exec::allowlist::{handle_add_to_allowlist, handle_remove_from_allowlist};
+use crate::exec::config::handle_update_config;
 use crate::exec::finality::handle_finality_signature;
 use crate::exec::public_randomness::handle_public_randomness_commit;
 use crate::msg::BabylonMsg;
@@ -159,6 +160,21 @@ pub fn execute(
         ExecuteMsg::RemoveFromAllowlist { fp_pubkey_hex_list } => {
             handle_remove_from_allowlist(deps, info, fp_pubkey_hex_list)
         }
+        ExecuteMsg::UpdateConfig {
+            min_pub_rand,
+            max_msgs_per_interval,
+            rate_limiting_interval,
+            bsn_activation_height,
+            finality_signature_interval,
+        } => handle_update_config(
+            deps,
+            info,
+            min_pub_rand,
+            max_msgs_per_interval,
+            rate_limiting_interval,
+            bsn_activation_height,
+            finality_signature_interval,
+        ),
     }
 }
 
@@ -1028,6 +1044,195 @@ pub(crate) mod tests {
         assert!(result.is_err());
     }
 
+    #[test]
+    fn test_update_config() {
+        let mut deps = mock_deps_babylon();
+        let admin = deps.api.addr_make(INIT_ADMIN);
+        let non_admin = deps.api.addr_make("non_admin");
+        let bsn_id = "op-stack-l2-11155420".to_string();
+        let min_pub_rand = 100;
+        let bsn_activation_height = 1000;
+        let finality_signature_interval = 100;
+
+        // Initialize contract
+        let instantiate_msg = InstantiateMsg {
+            admin: admin.to_string(),
+            bsn_id: bsn_id.clone(),
+            min_pub_rand,
+            max_msgs_per_interval: MAX_MSGS_PER_INTERVAL,
+            rate_limiting_interval: RATE_LIMITING_INTERVAL,
+            bsn_activation_height,
+            finality_signature_interval,
+            allowed_finality_providers: None,
+        };
+        let info = message_info(&deps.api.addr_make(CREATOR), &[]);
+        instantiate(deps.as_mut(), mock_env(), info, instantiate_msg).unwrap();
+
+        // Test 1: Admin can update individual fields
+        let update_msg = ExecuteMsg::UpdateConfig {
+            min_pub_rand: Some(200),
+            max_msgs_per_interval: None,
+            rate_limiting_interval: None,
+            bsn_activation_height: None,
+            finality_signature_interval: None,
+        };
+        let admin_info = message_info(&admin, &[]);
+        let res = execute(deps.as_mut(), mock_env(), admin_info.clone(), update_msg).unwrap();
+
+        assert_eq!(res.attributes.len(), 1);
+        assert_eq!(res.attributes[0].key, "action");
+        assert_eq!(res.attributes[0].value, "update_config");
+
+        // Verify config was updated
+        let config_query = query(deps.as_ref(), mock_env(), QueryMsg::Config {}).unwrap();
+        let config: Config = from_json(config_query).unwrap();
+        assert_eq!(config.bsn_id, bsn_id); // unchanged
+        assert_eq!(config.min_pub_rand, 200); // updated
+        assert_eq!(config.bsn_activation_height, bsn_activation_height); // unchanged
+        assert_eq!(
+            config.finality_signature_interval,
+            finality_signature_interval
+        ); // unchanged
+
+        // Test 2: Update multiple fields at once
+        let update_msg = ExecuteMsg::UpdateConfig {
+            min_pub_rand: Some(300),
+            max_msgs_per_interval: Some(150),
+            rate_limiting_interval: Some(15000),
+            bsn_activation_height: Some(2000),
+            finality_signature_interval: Some(200),
+        };
+        let res = execute(deps.as_mut(), mock_env(), admin_info.clone(), update_msg).unwrap();
+
+        assert_eq!(res.attributes.len(), 1);
+        assert_eq!(res.attributes[0].key, "action");
+        assert_eq!(res.attributes[0].value, "update_config");
+
+        // Verify all fields were updated
+        let config_query = query(deps.as_ref(), mock_env(), QueryMsg::Config {}).unwrap();
+        let config: Config = from_json(config_query).unwrap();
+        assert_eq!(config.bsn_id, bsn_id); // unchanged
+        assert_eq!(config.min_pub_rand, 300);
+        assert_eq!(config.rate_limiting.max_msgs_per_interval, 150);
+        assert_eq!(config.rate_limiting.block_interval, 15000);
+        assert_eq!(config.bsn_activation_height, 2000);
+        assert_eq!(config.finality_signature_interval, 200);
+
+        // Test 3: Non-admin cannot update config
+        let non_admin_info = message_info(&non_admin, &[]);
+        let update_msg = ExecuteMsg::UpdateConfig {
+            min_pub_rand: Some(999),
+            max_msgs_per_interval: None,
+            rate_limiting_interval: None,
+            bsn_activation_height: None,
+            finality_signature_interval: None,
+        };
+        let err = execute(deps.as_mut(), mock_env(), non_admin_info, update_msg).unwrap_err();
+        assert_eq!(err, ContractError::Admin(AdminError::NotAdmin {}));
+
+        // Test 4: Empty update should fail
+        let empty_update_msg = ExecuteMsg::UpdateConfig {
+            min_pub_rand: None,
+            max_msgs_per_interval: None,
+            rate_limiting_interval: None,
+            bsn_activation_height: None,
+            finality_signature_interval: None,
+        };
+        let err = execute(deps.as_mut(), mock_env(), admin_info, empty_update_msg).unwrap_err();
+        assert_eq!(err, ContractError::NoConfigFieldsToUpdate);
+    }
+
+    #[test]
+    fn test_update_config_validation() {
+        let mut deps = mock_deps_babylon();
+        let admin = deps.api.addr_make(INIT_ADMIN);
+        let bsn_id = "op-stack-l2-11155420".to_string();
+
+        // Initialize contract
+        let instantiate_msg = InstantiateMsg {
+            admin: admin.to_string(),
+            bsn_id,
+            min_pub_rand: 100,
+            max_msgs_per_interval: MAX_MSGS_PER_INTERVAL,
+            rate_limiting_interval: RATE_LIMITING_INTERVAL,
+            bsn_activation_height: 1000,
+            finality_signature_interval: 100,
+            allowed_finality_providers: None,
+        };
+        let info = message_info(&deps.api.addr_make(CREATOR), &[]);
+        instantiate(deps.as_mut(), mock_env(), info, instantiate_msg).unwrap();
+
+        let admin_info = message_info(&admin, &[]);
+
+        // Test invalid min_pub_rand
+        let invalid_min_pub_rand_update = ExecuteMsg::UpdateConfig {
+            min_pub_rand: Some(0), // invalid: must be > 0
+            max_msgs_per_interval: None,
+            rate_limiting_interval: None,
+            bsn_activation_height: None,
+            finality_signature_interval: None,
+        };
+        let err = execute(
+            deps.as_mut(),
+            mock_env(),
+            admin_info.clone(),
+            invalid_min_pub_rand_update,
+        )
+        .unwrap_err();
+        assert_eq!(err, ContractError::InvalidMinPubRand(0));
+
+        // Test invalid max_msgs_per_interval
+        let invalid_max_msgs_update = ExecuteMsg::UpdateConfig {
+            min_pub_rand: None,
+            max_msgs_per_interval: Some(0), // invalid: must be > 0
+            rate_limiting_interval: None,
+            bsn_activation_height: None,
+            finality_signature_interval: None,
+        };
+        let err = execute(
+            deps.as_mut(),
+            mock_env(),
+            admin_info.clone(),
+            invalid_max_msgs_update,
+        )
+        .unwrap_err();
+        assert_eq!(err, ContractError::InvalidMaxMsgsPerInterval(0));
+
+        // Test invalid rate_limiting_interval
+        let invalid_rate_interval_update = ExecuteMsg::UpdateConfig {
+            min_pub_rand: None,
+            max_msgs_per_interval: None,
+            rate_limiting_interval: Some(0), // invalid: must be > 0
+            bsn_activation_height: None,
+            finality_signature_interval: None,
+        };
+        let err = execute(
+            deps.as_mut(),
+            mock_env(),
+            admin_info.clone(),
+            invalid_rate_interval_update,
+        )
+        .unwrap_err();
+        assert_eq!(err, ContractError::InvalidRateLimitingInterval(0));
+
+        // Test invalid finality_signature_interval
+        let invalid_finality_interval_update = ExecuteMsg::UpdateConfig {
+            min_pub_rand: None,
+            max_msgs_per_interval: None,
+            rate_limiting_interval: None,
+            bsn_activation_height: None,
+            finality_signature_interval: Some(0), // invalid: must be > 0
+        };
+        let err = execute(
+            deps.as_mut(),
+            mock_env(),
+            admin_info,
+            invalid_finality_interval_update,
+        )
+        .unwrap_err();
+        assert_eq!(err, ContractError::InvalidFinalitySignatureInterval(0));
+    }
+
     #[test]
     fn test_allowlist_management() {
         use rand::rngs::StdRng;

contracts/finality/src/error.rs

@@ -105,4 +105,6 @@ pub enum ContractError {
     RateLimitExceeded { fp_btc_pk: String, limit: u32 },
     #[error("Finality provider {0} is not in the allowlist")]
     FinalityProviderNotAllowed(String),
+    #[error("No configuration fields were provided to update")]
+    NoConfigFieldsToUpdate,
 }

contracts/finality/src/exec/config.rs

@@ -0,0 +1,71 @@
+use cosmwasm_std::{DepsMut, MessageInfo, Response};
+
+use crate::error::ContractError;
+use crate::msg::BabylonMsg;
+use crate::state::config::{get_config, set_config, ADMIN};
+use crate::validation::{
+    validate_finality_signature_interval, validate_max_msgs_per_interval, validate_min_pub_rand,
+    validate_rate_limiting_interval,
+};
+use babylon_bindings::BabylonQuery;
+
+/// Handle updating the contract configuration
+pub fn handle_update_config(
+    deps: DepsMut<BabylonQuery>,
+    info: MessageInfo,
+    min_pub_rand: Option<u64>,
+    max_msgs_per_interval: Option<u32>,
+    rate_limiting_interval: Option<u64>,
+    bsn_activation_height: Option<u64>,
+    finality_signature_interval: Option<u64>,
+) -> Result<Response<BabylonMsg>, ContractError> {
+    // Only admin can update config
+    ADMIN.assert_admin(deps.as_ref(), &info.sender)?;
+
+    // Get current config
+    let mut config = get_config(deps.storage)?;
+    let mut has_updates = false;
+
+    // Update min_pub_rand if provided
+    if let Some(new_min_pub_rand) = min_pub_rand {
+        validate_min_pub_rand(new_min_pub_rand)?;
+        config.min_pub_rand = new_min_pub_rand;
+        has_updates = true;
+    }
+
+    // Update rate limiting config if any rate limiting fields are provided
+    if let Some(new_max_msgs) = max_msgs_per_interval {
+        validate_max_msgs_per_interval(new_max_msgs)?;
+        config.rate_limiting.max_msgs_per_interval = new_max_msgs;
+        has_updates = true;
+    }
+
+    if let Some(new_interval) = rate_limiting_interval {
+        validate_rate_limiting_interval(new_interval)?;
+        config.rate_limiting.block_interval = new_interval;
+        has_updates = true;
+    }
+
+    // Update bsn_activation_height if provided (no validation needed - any u64 is valid)
+    if let Some(new_activation_height) = bsn_activation_height {
+        config.bsn_activation_height = new_activation_height;
+        has_updates = true;
+    }
+
+    // Update finality_signature_interval if provided
+    if let Some(new_finality_interval) = finality_signature_interval {
+        validate_finality_signature_interval(new_finality_interval)?;
+        config.finality_signature_interval = new_finality_interval;
+        has_updates = true;
+    }
+
+    // Check if any fields were actually updated
+    if !has_updates {
+        return Err(ContractError::NoConfigFieldsToUpdate);
+    }
+
+    // Save the updated config
+    set_config(deps.storage, &config)?;
+
+    Ok(Response::new().add_attribute("action", "update_config"))
+}

contracts/finality/src/exec/mod.rs

@@ -1,3 +1,4 @@
 pub mod allowlist;
+pub mod config;
 pub mod finality;
 pub mod public_randomness;

contracts/finality/src/lib.rs

@@ -12,6 +12,7 @@ pub mod msg;
 pub mod queries;
 pub mod state;
 pub mod utils;
+pub mod validation;
 
 #[cfg_attr(not(feature = "library"), entry_point)]
 pub fn instantiate(