@layerzerolabs/protocol-stellar-v2 0.2.29 → 0.2.30

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

@@ -0,0 +1,267 @@
+//! set_supply_controller Integration Tests
+
+use super::test_helper::mock_set_supply_controller_auth;
+use crate::extensions::supply_control::SupplyControlClient;
+use crate::extensions::supply_control::{
+    LimitConfig, SupplyControlError, SupplyControllerAdded, SupplyControllerConfig, SupplyControllerRemoved,
+};
+use crate::tests::test_helper::TestSetup;
+use soroban_sdk::Vec;
+use utils::testing_utils::assert_eq_event;
+
+// =========================================================================
+// set_supply_controller Tests (add)
+// =========================================================================
+
+#[test]
+fn test_set_supply_controller() {
+    let setup = TestSetup::new().with_manager_as_sac_admin().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_000, refill_per_second: 100 },
+        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()));
+
+    // Verify SupplyControllerAdded event
+    let expected = SupplyControllerAdded { supply_controller: controller.clone(), config: config.clone() };
+    assert_eq_event(&setup.env, &setup.sac_manager, expected);
+
+    // Verify controller exists
+    let stored_config = sc_client.get_supply_controller_config(&controller);
+    assert!(stored_config.is_some());
+    assert_eq!(stored_config.unwrap().limit_config.limit_capacity, 1_000_000);
+}
+
+#[test]
+fn test_set_supply_controller_fails_if_already_exists() {
+    let setup = TestSetup::new().with_manager_as_sac_admin().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),
+    };
+
+    // Add supply controller first time - should succeed
+    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()));
+
+    // Try to add the same supply controller again - should fail
+    mock_set_supply_controller_auth(&setup, &setup.sc_manager, &controller, &Some(config.clone()));
+    let result = sc_client.try_set_supply_controller(&setup.sc_manager, &controller, &Some(config.clone()));
+    assert_eq!(result.err().unwrap().unwrap(), SupplyControlError::AlreadyExists.into());
+}
+
+#[test]
+fn test_set_supply_controller_fails_with_invalid_config() {
+    let setup = TestSetup::new().with_manager_as_sac_admin().build();
+    let sc_client = SupplyControlClient::new(&setup.env, &setup.sac_manager);
+
+    // Should fail due to negative capacity
+    let controller1 = setup.generate_address();
+    let invalid_config = SupplyControllerConfig {
+        limit_config: LimitConfig { limit_capacity: -100, refill_per_second: 10 },
+        allow_any_mint_burn: true,
+        whitelist_addresses: Vec::new(&setup.env),
+    };
+    mock_set_supply_controller_auth(&setup, &setup.sc_manager, &controller1, &Some(invalid_config.clone()));
+    let result = sc_client.try_set_supply_controller(&setup.sc_manager, &controller1, &Some(invalid_config.clone()));
+    assert_eq!(result.err().unwrap().unwrap(), SupplyControlError::InvalidConfig.into());
+
+    // Should fail due to negative refill rate
+    let controller2 = setup.generate_address();
+    let invalid_config = SupplyControllerConfig {
+        limit_config: LimitConfig { limit_capacity: 1000, refill_per_second: -10 },
+        allow_any_mint_burn: true,
+        whitelist_addresses: Vec::new(&setup.env),
+    };
+    mock_set_supply_controller_auth(&setup, &setup.sc_manager, &controller2, &Some(invalid_config.clone()));
+    let result = sc_client.try_set_supply_controller(&setup.sc_manager, &controller2, &Some(invalid_config.clone()));
+    assert_eq!(result.err().unwrap().unwrap(), SupplyControlError::InvalidConfig.into());
+}
+
+#[test]
+fn test_set_supply_controller_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),
+    };
+
+    // non_manager is NOT a supply controller manager — should fail
+    mock_set_supply_controller_auth(&setup, &non_manager, &controller, &Some(config.clone()));
+    let result = sc_client.try_set_supply_controller(&non_manager, &controller, &Some(config.clone()));
+    assert_eq!(result.err().unwrap().unwrap(), SupplyControlError::Unauthorized.into());
+}
+
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_set_supply_controller_without_auth() {
+    let setup = TestSetup::new().with_manager_as_sac_admin().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),
+    };
+
+    // sc_manager's auth is not mocked — sender.require_auth() fails
+    sc_client.set_supply_controller(&setup.sc_manager, &controller, &Some(config.clone()));
+}
+
+// =========================================================================
+// set_supply_controller Tests (remove)
+// =========================================================================
+
+#[test]
+fn test_set_supply_controller_remove() {
+    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_set_supply_controller_auth(&setup, &setup.sc_manager, &controller, &None);
+    sc_client.set_supply_controller(&setup.sc_manager, &controller, &None);
+
+    // Verify SupplyControllerRemoved event
+    let expected = SupplyControllerRemoved { supply_controller: controller.clone() };
+    assert_eq_event(&setup.env, &setup.sac_manager, expected);
+
+    // Verify controller config is removed
+    assert!(sc_client.get_supply_controller_config(&controller).is_none());
+}
+
+#[test]
+fn test_set_supply_controller_remove_fails_if_not_exists() {
+    let setup = TestSetup::new().build();
+    let non_controller = setup.generate_address();
+    let sc_client = SupplyControlClient::new(&setup.env, &setup.sac_manager);
+
+    mock_set_supply_controller_auth(&setup, &setup.sc_manager, &non_controller, &None);
+    let result = sc_client.try_set_supply_controller(&setup.sc_manager, &non_controller, &None);
+    assert_eq!(result.err().unwrap().unwrap(), SupplyControlError::NotFound.into());
+}
+
+#[test]
+fn test_get_supply_controllers() {
+    let setup = TestSetup::new().with_manager_as_sac_admin().build();
+    let sc_client = SupplyControlClient::new(&setup.env, &setup.sac_manager);
+
+    // Initially no supply controllers
+    let controllers = sc_client.get_supply_controllers();
+    assert_eq!(controllers.len(), 0);
+
+    let controller1 = setup.generate_address();
+    let controller2 = setup.generate_address();
+
+    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),
+    };
+
+    // Add two supply controllers
+    mock_set_supply_controller_auth(&setup, &setup.sc_manager, &controller1, &Some(config.clone()));
+    sc_client.set_supply_controller(&setup.sc_manager, &controller1, &Some(config.clone()));
+    mock_set_supply_controller_auth(&setup, &setup.sc_manager, &controller2, &Some(config.clone()));
+    sc_client.set_supply_controller(&setup.sc_manager, &controller2, &Some(config.clone()));
+
+    // Should return both controllers
+    let controllers = sc_client.get_supply_controllers();
+    assert_eq!(controllers.len(), 2);
+    assert!(controllers.contains(&controller1));
+    assert!(controllers.contains(&controller2));
+}
+
+#[test]
+fn test_get_supply_controllers_after_remove() {
+    let setup = TestSetup::new().build();
+    let controller1 = setup.generate_address();
+    let controller2 = 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),
+    };
+
+    // Add two supply controllers
+    mock_set_supply_controller_auth(&setup, &setup.sc_manager, &controller1, &Some(config.clone()));
+    sc_client.set_supply_controller(&setup.sc_manager, &controller1, &Some(config.clone()));
+    mock_set_supply_controller_auth(&setup, &setup.sc_manager, &controller2, &Some(config.clone()));
+    sc_client.set_supply_controller(&setup.sc_manager, &controller2, &Some(config.clone()));
+
+    // Remove one
+    mock_set_supply_controller_auth(&setup, &setup.sc_manager, &controller1, &None);
+    sc_client.set_supply_controller(&setup.sc_manager, &controller1, &None);
+
+    // Should return only one controller
+    let controllers = sc_client.get_supply_controllers();
+    assert_eq!(controllers.len(), 1);
+    assert!(!controllers.contains(&controller1));
+    assert!(controllers.contains(&controller2));
+}
+
+#[test]
+fn test_set_supply_controller_remove_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()));
+
+    // non_manager tries to remove — should fail
+    mock_set_supply_controller_auth(&setup, &non_manager, &controller, &None);
+    let result = sc_client.try_set_supply_controller(&non_manager, &controller, &None);
+    assert_eq!(result.err().unwrap().unwrap(), SupplyControlError::Unauthorized.into());
+}
+
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_set_supply_controller_remove_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 for the remove call — should panic
+    sc_client.set_supply_controller(&setup.sc_manager, &controller, &None);
+}

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

@@ -0,0 +1,122 @@
+//! 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

@@ -0,0 +1,38 @@
+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

@@ -0,0 +1,114 @@
+//! 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);
+}