@layerzerolabs/protocol-stellar-v2 0.2.33 → 0.2.34

package/contracts/sac-manager/src/tests/supply_control/set_supply_controller_manager.rs

@@ -1,122 +0,0 @@
-//! set_supply_controller_manager Integration Tests
-
-use super::test_helper::mock_set_supply_controller_manager_auth;
-use crate::extensions::supply_control::{SupplyControlError, SupplyCtrlManagerSet};
-use crate::tests::test_helper::TestSetup;
-use utils::testing_utils::assert_eq_event;
-
-// =========================================================================
-// set_supply_controller_manager Tests (add)
-// =========================================================================
-
-#[test]
-fn test_set_supply_controller_manager_add() {
-    let setup = TestSetup::new().build();
-    let new_manager = setup.generate_address();
-
-    mock_set_supply_controller_manager_auth(&setup, &new_manager, true);
-    setup.sac_manager_client.set_supply_controller_manager(&new_manager, &true);
-
-    // Verify event
-    let expected = SupplyCtrlManagerSet { manager: new_manager.clone(), active: true };
-    assert_eq_event(&setup.env, &setup.sac_manager, expected);
-
-    // Verify via view function
-    assert!(setup.sac_manager_client.is_supply_controller_manager(&new_manager));
-
-    // Verify manager list via view function
-    let managers = setup.sac_manager_client.get_supply_controller_managers();
-    assert_eq!(managers.len(), 2);
-    assert!(managers.contains(&setup.sc_manager));
-    assert!(managers.contains(&new_manager));
-
-    // Verify non-manager is not in the manager list
-    let non_manager = setup.generate_address();
-    assert!(!setup.sac_manager_client.is_supply_controller_manager(&non_manager));
-}
-
-#[test]
-fn test_set_supply_controller_manager_add_fails_if_already_exists() {
-    let setup = TestSetup::new().build();
-
-    // sc_manager was already added during TestSetup::build()
-    mock_set_supply_controller_manager_auth(&setup, &setup.sc_manager, true);
-    let result = setup.sac_manager_client.try_set_supply_controller_manager(&setup.sc_manager, &true);
-    assert_eq!(result.err().unwrap().unwrap(), SupplyControlError::AlreadyExists.into());
-}
-
-// =========================================================================
-// set_supply_controller_manager Tests (remove)
-// =========================================================================
-
-#[test]
-fn test_set_supply_controller_manager_remove() {
-    let setup = TestSetup::new().build();
-
-    // Verify sc_manager exists before removal
-    assert!(setup.sac_manager_client.is_supply_controller_manager(&setup.sc_manager));
-
-    mock_set_supply_controller_manager_auth(&setup, &setup.sc_manager, false);
-    setup.sac_manager_client.set_supply_controller_manager(&setup.sc_manager, &false);
-
-    // Verify event
-    let expected = SupplyCtrlManagerSet { manager: setup.sc_manager.clone(), active: false };
-    assert_eq_event(&setup.env, &setup.sac_manager, expected);
-
-    // Verify via view function
-    assert!(!setup.sac_manager_client.is_supply_controller_manager(&setup.sc_manager));
-}
-
-#[test]
-fn test_set_supply_controller_manager_remove_fails_if_not_found() {
-    let setup = TestSetup::new().build();
-    let non_manager = setup.generate_address();
-
-    mock_set_supply_controller_manager_auth(&setup, &non_manager, false);
-    let result = setup.sac_manager_client.try_set_supply_controller_manager(&non_manager, &false);
-    assert_eq!(result.err().unwrap().unwrap(), SupplyControlError::NotFound.into());
-}
-
-#[test]
-fn test_get_supply_controller_managers_after_remove() {
-    let setup = TestSetup::new().build();
-
-    // Add a second manager
-    let new_manager = setup.generate_address();
-    mock_set_supply_controller_manager_auth(&setup, &new_manager, true);
-    setup.sac_manager_client.set_supply_controller_manager(&new_manager, &true);
-
-    assert_eq!(setup.sac_manager_client.get_supply_controller_managers().len(), 2);
-
-    // Remove original manager
-    mock_set_supply_controller_manager_auth(&setup, &setup.sc_manager, false);
-    setup.sac_manager_client.set_supply_controller_manager(&setup.sc_manager, &false);
-
-    let managers: soroban_sdk::Vec<soroban_sdk::Address> = setup.sac_manager_client.get_supply_controller_managers();
-    assert_eq!(managers.len(), 1);
-    assert!(!managers.contains(&setup.sc_manager));
-    assert!(managers.contains(&new_manager));
-}
-
-// =========================================================================
-// Auth Tests (owner-only operations)
-// =========================================================================
-
-#[test]
-#[should_panic(expected = "Error(Auth, InvalidAction)")]
-fn test_set_supply_controller_manager_without_auth() {
-    let setup = TestSetup::new().without_oft().build();
-    let new_manager = setup.generate_address();
-
-    // No owner auth mocked — should panic
-    setup.sac_manager_client.set_supply_controller_manager(&new_manager, &true);
-}
-
-#[test]
-#[should_panic(expected = "Error(Auth, InvalidAction)")]
-fn test_set_supply_controller_manager_remove_without_auth() {
-    let setup = TestSetup::new().build();
-
-    // No auth mocked for this call — should panic
-    setup.sac_manager_client.set_supply_controller_manager(&setup.sc_manager, &false);
-}

package/contracts/sac-manager/src/tests/supply_control/test_helper.rs

@@ -1,38 +0,0 @@
-use crate::extensions::supply_control::LimitConfig;
-use crate::tests::test_helper::{mock_auth, TestSetup};
-use soroban_sdk::Address;
-
-pub use crate::tests::test_helper::{mock_oft_mint_auth, mock_set_supply_controller_auth};
-
-pub fn mock_update_limit_config_auth(setup: &TestSetup, sender: &Address, controller: &Address, limit: &LimitConfig) {
-    mock_auth(&setup.env, &setup.sac_manager, sender, "update_limit_config", (sender, controller, limit.clone()));
-}
-
-pub fn mock_update_allow_any_mint_burn_auth(
-    setup: &TestSetup,
-    sender: &Address,
-    controller: &Address,
-    allow_any_mint_burn: bool,
-) {
-    mock_auth(
-        &setup.env,
-        &setup.sac_manager,
-        sender,
-        "update_allow_any_mint_burn",
-        (sender, controller, allow_any_mint_burn),
-    );
-}
-
-pub fn mock_set_mint_whitelist_auth(
-    setup: &TestSetup,
-    sender: &Address,
-    controller: &Address,
-    mint_addr: &Address,
-    active: bool,
-) {
-    mock_auth(&setup.env, &setup.sac_manager, sender, "set_mint_whitelist", (sender, controller, mint_addr, active));
-}
-
-pub fn mock_set_supply_controller_manager_auth(setup: &TestSetup, manager: &Address, active: bool) {
-    mock_auth(&setup.env, &setup.sac_manager, &setup.owner, "set_supply_controller_manager", (manager, active));
-}

package/contracts/sac-manager/src/tests/supply_control/update_allow_any_mint_burn.rs

@@ -1,114 +0,0 @@
-//! update_allow_any_mint_burn Integration Tests
-
-use super::test_helper::{mock_set_mint_whitelist_auth, mock_set_supply_controller_auth, mock_update_allow_any_mint_burn_auth};
-use crate::extensions::supply_control::SupplyControlClient;
-use crate::extensions::supply_control::{
-    AllowAnyMintBurnUpdated, LimitConfig, SupplyControlError, SupplyControllerConfig,
-};
-use crate::tests::test_helper::TestSetup;
-use soroban_sdk::Vec;
-use utils::testing_utils::assert_eq_event;
-
-#[test]
-fn test_update_allow_any_mint_burn() {
-    let setup = TestSetup::new().build();
-    let controller = setup.generate_address();
-    let sc_client = SupplyControlClient::new(&setup.env, &setup.sac_manager);
-
-    let config = SupplyControllerConfig {
-        limit_config: LimitConfig { limit_capacity: 1_000, refill_per_second: 10 },
-        allow_any_mint_burn: true,
-        whitelist_addresses: Vec::new(&setup.env),
-    };
-    mock_set_supply_controller_auth(&setup, &setup.sc_manager, &controller, &Some(config.clone()));
-    sc_client.set_supply_controller(&setup.sc_manager, &controller, &Some(config.clone()));
-
-    mock_update_allow_any_mint_burn_auth(&setup, &setup.sc_manager, &controller, false);
-    sc_client.update_allow_any_mint_burn(&setup.sc_manager, &controller, &false);
-
-    // Verify event
-    let expected = AllowAnyMintBurnUpdated { supply_controller: controller.clone(), new_allow: false, old_allow: true };
-    assert_eq_event(&setup.env, &setup.sac_manager, expected);
-
-    // Verify config was updated
-    let stored = sc_client.get_supply_controller_config(&controller).unwrap();
-    assert!(!stored.allow_any_mint_burn);
-}
-
-#[test]
-fn test_update_allow_any_mint_burn_by_non_manager_fails() {
-    let setup = TestSetup::new().build();
-    let non_manager = setup.generate_address();
-    let controller = setup.generate_address();
-    let sc_client = SupplyControlClient::new(&setup.env, &setup.sac_manager);
-
-    let config = SupplyControllerConfig {
-        limit_config: LimitConfig { limit_capacity: 1_000, refill_per_second: 10 },
-        allow_any_mint_burn: true,
-        whitelist_addresses: Vec::new(&setup.env),
-    };
-    mock_set_supply_controller_auth(&setup, &setup.sc_manager, &controller, &Some(config.clone()));
-    sc_client.set_supply_controller(&setup.sc_manager, &controller, &Some(config));
-
-    mock_update_allow_any_mint_burn_auth(&setup, &non_manager, &controller, false);
-    let result = sc_client.try_update_allow_any_mint_burn(&non_manager, &controller, &false);
-    assert_eq!(result.err().unwrap().unwrap(), SupplyControlError::Unauthorized.into());
-}
-
-#[test]
-fn test_update_allow_any_mint_burn_fails_if_not_supply_controller() {
-    let setup = TestSetup::new().build();
-    let non_controller = setup.generate_address();
-    let sc_client = SupplyControlClient::new(&setup.env, &setup.sac_manager);
-
-    mock_update_allow_any_mint_burn_auth(&setup, &setup.sc_manager, &non_controller, false);
-    let result = sc_client.try_update_allow_any_mint_burn(&setup.sc_manager, &non_controller, &false);
-    assert_eq!(result.err().unwrap().unwrap(), SupplyControlError::NotFound.into());
-}
-
-#[test]
-fn test_update_allow_any_mint_burn_preserves_limit_and_whitelist() {
-    let setup = TestSetup::new().build();
-    let controller = setup.generate_address();
-    let whitelisted = setup.generate_address();
-    let sc_client = SupplyControlClient::new(&setup.env, &setup.sac_manager);
-
-    let config = SupplyControllerConfig {
-        limit_config: LimitConfig { limit_capacity: 2_000, refill_per_second: 20 },
-        allow_any_mint_burn: false,
-        whitelist_addresses: Vec::new(&setup.env),
-    };
-    mock_set_supply_controller_auth(&setup, &setup.sc_manager, &controller, &Some(config.clone()));
-    sc_client.set_supply_controller(&setup.sc_manager, &controller, &Some(config.clone()));
-
-    // Add whitelisted address before updating allow_any_mint_burn
-    mock_set_mint_whitelist_auth(&setup, &setup.sc_manager, &controller, &whitelisted, true);
-    sc_client.set_mint_whitelist(&setup.sc_manager, &controller, &whitelisted, &true);
-
-    mock_update_allow_any_mint_burn_auth(&setup, &setup.sc_manager, &controller, true);
-    sc_client.update_allow_any_mint_burn(&setup.sc_manager, &controller, &true);
-
-    let stored = sc_client.get_supply_controller_config(&controller).unwrap();
-    assert!(stored.allow_any_mint_burn);
-    assert_eq!(stored.limit_config, config.limit_config);
-    assert!(sc_client.is_address_whitelisted(&controller, &whitelisted));
-}
-
-#[test]
-#[should_panic(expected = "Error(Auth, InvalidAction)")]
-fn test_update_allow_any_mint_burn_without_auth() {
-    let setup = TestSetup::new().build();
-    let controller = setup.generate_address();
-    let sc_client = SupplyControlClient::new(&setup.env, &setup.sac_manager);
-
-    let config = SupplyControllerConfig {
-        limit_config: LimitConfig { limit_capacity: 1_000, refill_per_second: 10 },
-        allow_any_mint_burn: true,
-        whitelist_addresses: Vec::new(&setup.env),
-    };
-    mock_set_supply_controller_auth(&setup, &setup.sc_manager, &controller, &Some(config.clone()));
-    sc_client.set_supply_controller(&setup.sc_manager, &controller, &Some(config.clone()));
-
-    // sc_manager's auth is not mocked — sender.require_auth() fails
-    sc_client.update_allow_any_mint_burn(&setup.sc_manager, &controller, &false);
-}

package/contracts/sac-manager/src/tests/supply_control/update_limit_config.rs

@@ -1,257 +0,0 @@
-//! update_limit_config Integration Tests
-
-use super::test_helper::{
-    mock_oft_mint_auth, mock_set_mint_whitelist_auth, mock_set_supply_controller_auth, mock_update_limit_config_auth,
-};
-use crate::extensions::supply_control::SupplyControlClient;
-use crate::extensions::supply_control::{LimitConfig, LimitConfigUpdated, SupplyControlError, SupplyControllerConfig};
-use crate::tests::test_helper::TestSetup;
-use soroban_sdk::Vec;
-use utils::testing_utils::assert_eq_event;
-
-#[test]
-fn test_update_limit_config() {
-    let setup = TestSetup::new().build();
-    let controller = setup.generate_address();
-    let sc_client = SupplyControlClient::new(&setup.env, &setup.sac_manager);
-
-    let config = SupplyControllerConfig {
-        limit_config: LimitConfig { limit_capacity: 1_000, refill_per_second: 10 },
-        allow_any_mint_burn: true,
-        whitelist_addresses: Vec::new(&setup.env),
-    };
-    mock_set_supply_controller_auth(&setup, &setup.sc_manager, &controller, &Some(config.clone()));
-    sc_client.set_supply_controller(&setup.sc_manager, &controller, &Some(config.clone()));
-
-    let new_limit = LimitConfig { limit_capacity: 5_000, refill_per_second: 50 };
-    mock_update_limit_config_auth(&setup, &setup.sc_manager, &controller, &new_limit);
-    sc_client.update_limit_config(&setup.sc_manager, &controller, &new_limit);
-
-    // Verify event
-    let expected = LimitConfigUpdated {
-        supply_controller: controller.clone(),
-        new_limit_config: new_limit.clone(),
-        old_limit_config: config.limit_config,
-    };
-    assert_eq_event(&setup.env, &setup.sac_manager, expected);
-
-    // Verify config was updated
-    let stored = sc_client.get_supply_controller_config(&controller).unwrap();
-    assert_eq!(stored.limit_config.limit_capacity, 5_000);
-    assert_eq!(stored.limit_config.refill_per_second, 50);
-}
-
-#[test]
-fn test_update_limit_config_preserves_rate_limit_state() {
-    let setup = TestSetup::new().with_manager_as_sac_admin().with_supply_control_enabled().build();
-    let sc_client = SupplyControlClient::new(&setup.env, &setup.sac_manager);
-
-    let config = SupplyControllerConfig {
-        limit_config: LimitConfig { limit_capacity: 1_000, refill_per_second: 1 },
-        allow_any_mint_burn: true,
-        whitelist_addresses: Vec::new(&setup.env),
-    };
-    mock_set_supply_controller_auth(&setup, &setup.sc_manager, &setup.oft, &Some(config.clone()));
-    sc_client.set_supply_controller(&setup.sc_manager, &setup.oft, &Some(config.clone()));
-
-    // Mint some tokens to consume rate limit
-    let recipient = setup.generate_address();
-    mock_oft_mint_auth(&setup, &recipient, 400_i128);
-    setup.sac_manager_client.mint(&recipient, &400);
-    assert_eq!(sc_client.get_remaining_mint_amount(&setup.oft), 600);
-
-    // Update limit config (should NOT reset remaining amount)
-    let new_limit = LimitConfig { limit_capacity: 2_000, refill_per_second: 1 };
-    mock_update_limit_config_auth(&setup, &setup.sc_manager, &setup.oft, &new_limit);
-    sc_client.update_limit_config(&setup.sc_manager, &setup.oft, &new_limit);
-
-    // Remaining amount should still be 600 (not reset to 2000)
-    assert_eq!(sc_client.get_remaining_mint_amount(&setup.oft), 600);
-}
-
-#[test]
-fn test_update_limit_config_fails_with_invalid_config() {
-    let setup = TestSetup::new().build();
-    let controller = setup.generate_address();
-    let sc_client = SupplyControlClient::new(&setup.env, &setup.sac_manager);
-
-    let config = SupplyControllerConfig {
-        limit_config: LimitConfig { limit_capacity: 1_000, refill_per_second: 10 },
-        allow_any_mint_burn: true,
-        whitelist_addresses: Vec::new(&setup.env),
-    };
-    mock_set_supply_controller_auth(&setup, &setup.sc_manager, &controller, &Some(config.clone()));
-    sc_client.set_supply_controller(&setup.sc_manager, &controller, &Some(config.clone()));
-
-    let invalid_limit = LimitConfig { limit_capacity: -100, refill_per_second: 10 };
-    mock_update_limit_config_auth(&setup, &setup.sc_manager, &controller, &invalid_limit);
-    let result = sc_client.try_update_limit_config(&setup.sc_manager, &controller, &invalid_limit);
-    assert_eq!(result.err().unwrap().unwrap(), SupplyControlError::InvalidConfig.into());
-
-    // Verify config remains unchanged after failed update.
-    let stored = sc_client.get_supply_controller_config(&controller).unwrap();
-    assert_eq!(stored.limit_config, config.limit_config);
-}
-
-#[test]
-fn test_update_limit_config_fails_with_negative_refill_per_second() {
-    let setup = TestSetup::new().build();
-    let controller = setup.generate_address();
-    let sc_client = SupplyControlClient::new(&setup.env, &setup.sac_manager);
-
-    let config = SupplyControllerConfig {
-        limit_config: LimitConfig { limit_capacity: 1_000, refill_per_second: 10 },
-        allow_any_mint_burn: true,
-        whitelist_addresses: Vec::new(&setup.env),
-    };
-    mock_set_supply_controller_auth(&setup, &setup.sc_manager, &controller, &Some(config.clone()));
-    sc_client.set_supply_controller(&setup.sc_manager, &controller, &Some(config.clone()));
-
-    let invalid_limit = LimitConfig { limit_capacity: 1_000, refill_per_second: -1 };
-    mock_update_limit_config_auth(&setup, &setup.sc_manager, &controller, &invalid_limit);
-    let result = sc_client.try_update_limit_config(&setup.sc_manager, &controller, &invalid_limit);
-    assert_eq!(result.err().unwrap().unwrap(), SupplyControlError::InvalidConfig.into());
-
-    // Verify config remains unchanged after failed update.
-    let stored = sc_client.get_supply_controller_config(&controller).unwrap();
-    assert_eq!(stored.limit_config, config.limit_config);
-}
-
-#[test]
-fn test_update_limit_config_preserves_allow_any_and_whitelist() {
-    let setup = TestSetup::new().build();
-    let controller = setup.generate_address();
-    let whitelisted = setup.generate_address();
-    let sc_client = SupplyControlClient::new(&setup.env, &setup.sac_manager);
-
-    let config = SupplyControllerConfig {
-        limit_config: LimitConfig { limit_capacity: 1_000, refill_per_second: 10 },
-        allow_any_mint_burn: false,
-        whitelist_addresses: Vec::new(&setup.env),
-    };
-    mock_set_supply_controller_auth(&setup, &setup.sc_manager, &controller, &Some(config.clone()));
-    sc_client.set_supply_controller(&setup.sc_manager, &controller, &Some(config.clone()));
-
-    // Add whitelisted address before updating limit config
-    mock_set_mint_whitelist_auth(&setup, &setup.sc_manager, &controller, &whitelisted, true);
-    sc_client.set_mint_whitelist(&setup.sc_manager, &controller, &whitelisted, &true);
-
-    let new_limit = LimitConfig { limit_capacity: 3_000, refill_per_second: 30 };
-    mock_update_limit_config_auth(&setup, &setup.sc_manager, &controller, &new_limit);
-    sc_client.update_limit_config(&setup.sc_manager, &controller, &new_limit);
-
-    let stored = sc_client.get_supply_controller_config(&controller).unwrap();
-    assert_eq!(stored.limit_config, new_limit);
-    assert_eq!(stored.allow_any_mint_burn, config.allow_any_mint_burn);
-    assert!(sc_client.is_address_whitelisted(&controller, &whitelisted));
-}
-
-#[test]
-fn test_update_limit_config_switch_to_unlimited_and_back() {
-    let setup = TestSetup::new().with_manager_as_sac_admin().with_supply_control_enabled().build();
-    let sc_client = SupplyControlClient::new(&setup.env, &setup.sac_manager);
-
-    let config = SupplyControllerConfig {
-        limit_config: LimitConfig { limit_capacity: 1_000, refill_per_second: 1 },
-        allow_any_mint_burn: true,
-        whitelist_addresses: Vec::new(&setup.env),
-    };
-    mock_set_supply_controller_auth(&setup, &setup.sc_manager, &setup.oft, &Some(config.clone()));
-    sc_client.set_supply_controller(&setup.sc_manager, &setup.oft, &Some(config));
-
-    let recipient = setup.generate_address();
-    mock_oft_mint_auth(&setup, &recipient, 400_i128);
-    setup.sac_manager_client.mint(&recipient, &400);
-    assert_eq!(sc_client.get_remaining_mint_amount(&setup.oft), 600);
-
-    let unlimited = LimitConfig { limit_capacity: 1_000, refill_per_second: 0 };
-    mock_update_limit_config_auth(&setup, &setup.sc_manager, &setup.oft, &unlimited);
-    sc_client.update_limit_config(&setup.sc_manager, &setup.oft, &unlimited);
-    assert_eq!(sc_client.get_remaining_mint_amount(&setup.oft), i128::MAX);
-
-    let limited_again = LimitConfig { limit_capacity: 2_000, refill_per_second: 1 };
-    mock_update_limit_config_auth(&setup, &setup.sc_manager, &setup.oft, &limited_again);
-    sc_client.update_limit_config(&setup.sc_manager, &setup.oft, &limited_again);
-    assert_eq!(sc_client.get_remaining_mint_amount(&setup.oft), 600);
-}
-
-#[test]
-fn test_update_limit_config_event_tracks_previous_value_across_updates() {
-    let setup = TestSetup::new().build();
-    let controller = setup.generate_address();
-    let sc_client = SupplyControlClient::new(&setup.env, &setup.sac_manager);
-
-    let initial = LimitConfig { limit_capacity: 1_000, refill_per_second: 10 };
-    let config = SupplyControllerConfig {
-        limit_config: initial.clone(),
-        allow_any_mint_burn: true,
-        whitelist_addresses: Vec::new(&setup.env),
-    };
-    mock_set_supply_controller_auth(&setup, &setup.sc_manager, &controller, &Some(config.clone()));
-    sc_client.set_supply_controller(&setup.sc_manager, &controller, &Some(config));
-
-    let first = LimitConfig { limit_capacity: 2_000, refill_per_second: 20 };
-    mock_update_limit_config_auth(&setup, &setup.sc_manager, &controller, &first);
-    sc_client.update_limit_config(&setup.sc_manager, &controller, &first);
-
-    let second = LimitConfig { limit_capacity: 3_000, refill_per_second: 30 };
-    mock_update_limit_config_auth(&setup, &setup.sc_manager, &controller, &second);
-    sc_client.update_limit_config(&setup.sc_manager, &controller, &second);
-
-    let expected =
-        LimitConfigUpdated { supply_controller: controller, new_limit_config: second, old_limit_config: first };
-    assert_eq_event(&setup.env, &setup.sac_manager, expected);
-}
-
-#[test]
-fn test_update_limit_config_fails_if_not_supply_controller() {
-    let setup = TestSetup::new().build();
-    let non_controller = setup.generate_address();
-    let sc_client = SupplyControlClient::new(&setup.env, &setup.sac_manager);
-
-    let limit = LimitConfig { limit_capacity: 1_000, refill_per_second: 10 };
-    mock_update_limit_config_auth(&setup, &setup.sc_manager, &non_controller, &limit);
-    let result = sc_client.try_update_limit_config(&setup.sc_manager, &non_controller, &limit);
-    assert_eq!(result.err().unwrap().unwrap(), SupplyControlError::NotFound.into());
-}
-
-#[test]
-fn test_update_limit_config_by_non_manager_fails() {
-    let setup = TestSetup::new().build();
-    let non_manager = setup.generate_address();
-    let controller = setup.generate_address();
-    let sc_client = SupplyControlClient::new(&setup.env, &setup.sac_manager);
-
-    let config = SupplyControllerConfig {
-        limit_config: LimitConfig { limit_capacity: 1_000, refill_per_second: 10 },
-        allow_any_mint_burn: true,
-        whitelist_addresses: Vec::new(&setup.env),
-    };
-    mock_set_supply_controller_auth(&setup, &setup.sc_manager, &controller, &Some(config.clone()));
-    sc_client.set_supply_controller(&setup.sc_manager, &controller, &Some(config.clone()));
-
-    let new_limit = LimitConfig { limit_capacity: 5_000, refill_per_second: 50 };
-    mock_update_limit_config_auth(&setup, &non_manager, &controller, &new_limit);
-    let result = sc_client.try_update_limit_config(&non_manager, &controller, &new_limit);
-    assert_eq!(result.err().unwrap().unwrap(), SupplyControlError::Unauthorized.into());
-}
-
-#[test]
-#[should_panic(expected = "Error(Auth, InvalidAction)")]
-fn test_update_limit_config_without_auth() {
-    let setup = TestSetup::new().build();
-    let controller = setup.generate_address();
-    let sc_client = SupplyControlClient::new(&setup.env, &setup.sac_manager);
-
-    let config = SupplyControllerConfig {
-        limit_config: LimitConfig { limit_capacity: 1_000, refill_per_second: 10 },
-        allow_any_mint_burn: true,
-        whitelist_addresses: Vec::new(&setup.env),
-    };
-    mock_set_supply_controller_auth(&setup, &setup.sc_manager, &controller, &Some(config.clone()));
-    sc_client.set_supply_controller(&setup.sc_manager, &controller, &Some(config.clone()));
-
-    // sc_manager's auth is not mocked — sender.require_auth() fails
-    let new_limit = LimitConfig { limit_capacity: 5_000, refill_per_second: 50 };
-    sc_client.update_limit_config(&setup.sc_manager, &controller, &new_limit);
-}