@layerzerolabs/protocol-stellar-v2 0.2.29 → 0.2.30

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

@@ -0,0 +1,256 @@
+//! Supply Controller Add/Remove & Enumeration Edge-Case Tests
+//!
+//! Focuses on add/remove controller mechanics, re-adding after
+//! removal, removing all controllers, and verifying initial rate-limit state.
+
+use super::test_helper::mock_set_supply_controller_auth;
+use crate::extensions::supply_control::{LimitConfig, SupplyControlClient, SupplyControlError, SupplyControllerConfig};
+use crate::tests::test_helper::TestSetup;
+use soroban_sdk::{Env, Vec};
+
+// =========================================================================
+// Helpers
+// =========================================================================
+
+fn default_config(env: &Env) -> SupplyControllerConfig {
+    SupplyControllerConfig {
+        limit_config: LimitConfig { limit_capacity: 1_000, refill_per_second: 10 },
+        allow_any_mint_burn: true,
+        whitelist_addresses: Vec::new(env),
+    }
+}
+
+fn add(setup: &TestSetup, sc_client: &SupplyControlClient, controller: &soroban_sdk::Address) {
+    let config = default_config(&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));
+}
+
+fn remove(setup: &TestSetup, sc_client: &SupplyControlClient, controller: &soroban_sdk::Address) {
+    mock_set_supply_controller_auth(setup, &setup.sc_manager, controller, &None);
+    sc_client.set_supply_controller(&setup.sc_manager, controller, &None);
+}
+
+// =========================================================================
+// Initial Rate-Limit State
+// =========================================================================
+
+#[test]
+fn test_add_supply_controller_initial_rate_limit_state() {
+    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: 5_000, refill_per_second: 50 },
+        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()));
+
+    // remaining_mint_amount should equal limit_capacity at t=0
+    let remaining = sc_client.get_remaining_mint_amount(&controller);
+    assert_eq!(remaining, 5_000);
+
+    // Config should match what we set
+    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);
+    assert_eq!(stored.allow_any_mint_burn, false);
+}
+
+// =========================================================================
+// Re-add After Removal
+// =========================================================================
+
+#[test]
+fn test_readd_supply_controller_after_removal() {
+    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);
+
+    // Add, remove, then add again — should succeed
+    add(&setup, &sc_client, &controller);
+    assert!(sc_client.get_supply_controller_config(&controller).is_some());
+
+    remove(&setup, &sc_client, &controller);
+    assert!(sc_client.get_supply_controller_config(&controller).is_none());
+
+    add(&setup, &sc_client, &controller);
+    assert!(sc_client.get_supply_controller_config(&controller).is_some());
+}
+
+// =========================================================================
+// Remove From Middle / First / Last
+// =========================================================================
+
+#[test]
+fn test_remove_middle_controller() {
+    let setup = TestSetup::new().with_manager_as_sac_admin().build();
+    let sc_client = SupplyControlClient::new(&setup.env, &setup.sac_manager);
+
+    let c1 = setup.generate_address();
+    let c2 = setup.generate_address();
+    let c3 = setup.generate_address();
+
+    add(&setup, &sc_client, &c1);
+    add(&setup, &sc_client, &c2);
+    add(&setup, &sc_client, &c3);
+
+    // Remove the middle controller (c2).
+    remove(&setup, &sc_client, &c2);
+
+    let controllers = sc_client.get_supply_controllers();
+    assert_eq!(controllers.len(), 2);
+    assert!(controllers.contains(&c1));
+    assert!(controllers.contains(&c3));
+    assert!(!controllers.contains(&c2));
+}
+
+#[test]
+fn test_remove_first_controller() {
+    let setup = TestSetup::new().with_manager_as_sac_admin().build();
+    let sc_client = SupplyControlClient::new(&setup.env, &setup.sac_manager);
+
+    let c1 = setup.generate_address();
+    let c2 = setup.generate_address();
+    let c3 = setup.generate_address();
+
+    add(&setup, &sc_client, &c1);
+    add(&setup, &sc_client, &c2);
+    add(&setup, &sc_client, &c3);
+
+    // Remove first controller (c1).
+    remove(&setup, &sc_client, &c1);
+
+    let controllers = sc_client.get_supply_controllers();
+    assert_eq!(controllers.len(), 2);
+    assert!(controllers.contains(&c2));
+    assert!(controllers.contains(&c3));
+    assert!(!controllers.contains(&c1));
+}
+
+#[test]
+fn test_remove_last_controller() {
+    let setup = TestSetup::new().with_manager_as_sac_admin().build();
+    let sc_client = SupplyControlClient::new(&setup.env, &setup.sac_manager);
+
+    let c1 = setup.generate_address();
+    let c2 = setup.generate_address();
+    let c3 = setup.generate_address();
+
+    add(&setup, &sc_client, &c1);
+    add(&setup, &sc_client, &c2);
+    add(&setup, &sc_client, &c3);
+
+    // Remove last controller.
+    remove(&setup, &sc_client, &c3);
+
+    let controllers = sc_client.get_supply_controllers();
+    assert_eq!(controllers.len(), 2);
+    assert!(controllers.contains(&c1));
+    assert!(controllers.contains(&c2));
+}
+
+// =========================================================================
+// Remove All Controllers
+// =========================================================================
+
+#[test]
+fn test_remove_all_controllers() {
+    let setup = TestSetup::new().with_manager_as_sac_admin().build();
+    let sc_client = SupplyControlClient::new(&setup.env, &setup.sac_manager);
+
+    let c1 = setup.generate_address();
+    let c2 = setup.generate_address();
+
+    add(&setup, &sc_client, &c1);
+    add(&setup, &sc_client, &c2);
+
+    remove(&setup, &sc_client, &c1);
+    remove(&setup, &sc_client, &c2);
+
+    let controllers = sc_client.get_supply_controllers();
+    assert_eq!(controllers.len(), 0);
+}
+
+#[test]
+fn test_remove_single_controller() {
+    let setup = TestSetup::new().with_manager_as_sac_admin().build();
+    let sc_client = SupplyControlClient::new(&setup.env, &setup.sac_manager);
+
+    let c1 = setup.generate_address();
+    add(&setup, &sc_client, &c1);
+
+    remove(&setup, &sc_client, &c1);
+
+    let controllers = sc_client.get_supply_controllers();
+    assert_eq!(controllers.len(), 0);
+    assert!(sc_client.get_supply_controller_config(&c1).is_none());
+}
+
+// =========================================================================
+// Get All Controllers
+// =========================================================================
+
+#[test]
+fn test_get_supply_controllers_empty() {
+    let setup = TestSetup::new().with_manager_as_sac_admin().build();
+    let sc_client = SupplyControlClient::new(&setup.env, &setup.sac_manager);
+
+    let controllers = sc_client.get_supply_controllers();
+    assert_eq!(controllers.len(), 0);
+}
+
+// =========================================================================
+// Multiple Add/Remove Cycles
+// =========================================================================
+
+#[test]
+fn test_multiple_add_remove_cycles() {
+    let setup = TestSetup::new().with_manager_as_sac_admin().build();
+    let sc_client = SupplyControlClient::new(&setup.env, &setup.sac_manager);
+
+    let c1 = setup.generate_address();
+    let c2 = setup.generate_address();
+    let c3 = setup.generate_address();
+
+    // Add all three
+    add(&setup, &sc_client, &c1);
+    add(&setup, &sc_client, &c2);
+    add(&setup, &sc_client, &c3);
+
+    // Remove middle, then re-add it
+    remove(&setup, &sc_client, &c2);
+    add(&setup, &sc_client, &c2);
+
+    let controllers = sc_client.get_supply_controllers();
+    assert_eq!(controllers.len(), 3);
+    assert!(controllers.contains(&c1));
+    assert!(controllers.contains(&c2));
+    assert!(controllers.contains(&c3));
+
+    // Remove first two, verify only c3 remains
+    remove(&setup, &sc_client, &c1);
+    remove(&setup, &sc_client, &c2);
+
+    let controllers = sc_client.get_supply_controllers();
+    assert_eq!(controllers.len(), 1);
+    assert!(controllers.contains(&c3));
+}
+
+#[test]
+fn test_remove_already_removed_fails() {
+    let setup = TestSetup::new().with_manager_as_sac_admin().build();
+    let sc_client = SupplyControlClient::new(&setup.env, &setup.sac_manager);
+
+    let c1 = setup.generate_address();
+    add(&setup, &sc_client, &c1);
+    remove(&setup, &sc_client, &c1);
+
+    // Removing again should fail with NotFound
+    mock_set_supply_controller_auth(&setup, &setup.sc_manager, &c1, &None);
+    let result = sc_client.try_set_supply_controller(&setup.sc_manager, &c1, &None);
+    assert_eq!(result.err().unwrap().unwrap(), SupplyControlError::NotFound.into());
+}

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

@@ -0,0 +1,8 @@
+mod enumerable_set;
+mod refill;
+mod set_mint_whitelist;
+mod set_supply_controller;
+mod set_supply_controller_manager;
+mod test_helper;
+mod update_allow_any_mint_burn;
+mod update_limit_config;

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

@@ -0,0 +1,90 @@
+//! refill() Unit Tests
+//!
+//! Unit tests for the pure `refill` helper in the supply control extension.
+//! These tests do not require deploying the SacManager contract.
+
+use crate::extensions::supply_control::rate_limit::{test::refill_for_test, LimitConfig, RateLimitState};
+use crate::extensions::supply_control::SupplyControlError;
+
+#[test]
+fn test_refill_no_time_elapsed() {
+    let limit_config = LimitConfig { limit_capacity: 1000, refill_per_second: 10 };
+    let state = RateLimitState { remaining_amount: 500, last_refill_time: 100 };
+
+    // No time elapsed
+    let result = refill_for_test(&limit_config, &state, 100).unwrap();
+    assert_eq!(result, 500);
+}
+
+#[test]
+fn test_refill_partial_refill() {
+    let limit_config = LimitConfig { limit_capacity: 1000, refill_per_second: 10 };
+    let state = RateLimitState { remaining_amount: 500, last_refill_time: 100 };
+
+    // 10 seconds elapsed = 100 tokens refilled
+    let result = refill_for_test(&limit_config, &state, 110).unwrap();
+    assert_eq!(result, 600);
+}
+
+#[test]
+fn test_refill_capped_at_capacity() {
+    let limit_config = LimitConfig { limit_capacity: 1000, refill_per_second: 10 };
+    let state = RateLimitState { remaining_amount: 950, last_refill_time: 100 };
+
+    // 100 seconds elapsed = 1000 tokens, but capped at capacity
+    let result = refill_for_test(&limit_config, &state, 200).unwrap();
+    assert_eq!(result, 1000);
+}
+
+#[test]
+fn test_refill_from_zero() {
+    let limit_config = LimitConfig { limit_capacity: 1000, refill_per_second: 100 };
+    let state = RateLimitState { remaining_amount: 0, last_refill_time: 0 };
+
+    // 5 seconds elapsed = 500 tokens
+    let result = refill_for_test(&limit_config, &state, 5).unwrap();
+    assert_eq!(result, 500);
+}
+
+#[test]
+fn test_refill_with_zero_refill_rate() {
+    // Note: In practice, refill_per_second=0 means unlimited (checked elsewhere)
+    // but the refill function itself just does the math
+    let limit_config = LimitConfig { limit_capacity: 1000, refill_per_second: 0 };
+    let state = RateLimitState { remaining_amount: 500, last_refill_time: 100 };
+
+    // Any time elapsed, but no refill since rate is 0
+    let result = refill_for_test(&limit_config, &state, 200).unwrap();
+    assert_eq!(result, 500);
+}
+
+#[test]
+fn test_refill_returns_capacity_on_overflow() {
+    // On arithmetic overflow, returns limit_capacity (aligned with EVM RateLimiter)
+    let limit_config = LimitConfig { limit_capacity: 5_000, refill_per_second: i128::MAX / 2 };
+    let state = RateLimitState { remaining_amount: i128::MAX / 2, last_refill_time: 0 };
+
+    // Multiplication overflows → returns limit_capacity
+    let result = refill_for_test(&limit_config, &state, 1000).unwrap();
+    assert_eq!(result, 5_000);
+}
+
+#[test]
+fn test_refill_returns_capacity_on_add_overflow() {
+    // Addition overflows → returns limit_capacity
+    let limit_config = LimitConfig { limit_capacity: 10_000, refill_per_second: 1 };
+    let state = RateLimitState { remaining_amount: i128::MAX, last_refill_time: 0 };
+
+    let result = refill_for_test(&limit_config, &state, 10).unwrap();
+    assert_eq!(result, 10_000);
+}
+
+#[test]
+fn test_refill_errors_on_old_timestamp() {
+    let limit_config = LimitConfig { limit_capacity: 1000, refill_per_second: 10 };
+    let state = RateLimitState { remaining_amount: 500, last_refill_time: 200 };
+
+    // timestamp (100) < last_refill_time (200) → should return Err
+    let result = refill_for_test(&limit_config, &state, 100);
+    assert_eq!(result.err().unwrap(), SupplyControlError::OldTimestamp.into());
+}

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

@@ -0,0 +1,245 @@
+//! set_mint_whitelist Integration Tests
+
+use super::test_helper::{mock_set_mint_whitelist_auth, mock_set_supply_controller_auth};
+use crate::extensions::supply_control::SupplyControlClient;
+use crate::extensions::supply_control::{LimitConfig, MintWhitelistSet, SupplyControlError, SupplyControllerConfig};
+use crate::tests::test_helper::TestSetup;
+use soroban_sdk::Vec;
+use utils::testing_utils::assert_eq_event;
+
+#[test]
+fn test_set_mint_whitelist_add() {
+    let setup = TestSetup::new().build();
+    let controller = setup.generate_address();
+    let mint_addr = 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: 0 },
+        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()));
+
+    mock_set_mint_whitelist_auth(&setup, &setup.sc_manager, &controller, &mint_addr, true);
+    sc_client.set_mint_whitelist(&setup.sc_manager, &controller, &mint_addr, &true);
+
+    // Verify event
+    let expected =
+        MintWhitelistSet { supply_controller: controller.clone(), mint_address: mint_addr.clone(), active: true };
+    assert_eq_event(&setup.env, &setup.sac_manager, expected);
+
+    // Verify whitelist updated
+    assert!(sc_client.is_address_whitelisted(&controller, &mint_addr));
+}
+
+#[test]
+fn test_set_mint_whitelist_add_fails_if_duplicate() {
+    let setup = TestSetup::new().build();
+    let controller = setup.generate_address();
+    let mint_addr = 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: 0 },
+        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()));
+
+    // Pre-populate the whitelist with mint_addr
+    mock_set_mint_whitelist_auth(&setup, &setup.sc_manager, &controller, &mint_addr, true);
+    sc_client.set_mint_whitelist(&setup.sc_manager, &controller, &mint_addr, &true);
+
+    // Attempt to add the same address again — should fail
+    mock_set_mint_whitelist_auth(&setup, &setup.sc_manager, &controller, &mint_addr, true);
+    let result = sc_client.try_set_mint_whitelist(&setup.sc_manager, &controller, &mint_addr, &true);
+    assert_eq!(result.err().unwrap().unwrap(), SupplyControlError::AlreadyExists.into());
+
+    // Verify whitelist remains unchanged after failed update.
+    assert!(sc_client.is_address_whitelisted(&controller, &mint_addr));
+}
+
+#[test]
+fn test_set_mint_whitelist_add_by_non_manager_fails() {
+    let setup = TestSetup::new().build();
+    let non_manager = setup.generate_address();
+    let controller = setup.generate_address();
+    let mint_addr = 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: 0 },
+        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));
+
+    mock_set_mint_whitelist_auth(&setup, &non_manager, &controller, &mint_addr, true);
+    let result = sc_client.try_set_mint_whitelist(&non_manager, &controller, &mint_addr, &true);
+    assert_eq!(result.err().unwrap().unwrap(), SupplyControlError::Unauthorized.into());
+}
+
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_set_mint_whitelist_add_without_auth() {
+    let setup = TestSetup::new().build();
+    let controller = setup.generate_address();
+    let mint_addr = 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: 0 },
+        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()));
+
+    // sc_manager's auth is not mocked — sender.require_auth() fails
+    sc_client.set_mint_whitelist(&setup.sc_manager, &controller, &mint_addr, &true);
+}
+
+#[test]
+fn test_set_mint_whitelist_remove() {
+    let setup = TestSetup::new().build();
+    let controller = setup.generate_address();
+    let mint_addr = 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: 0 },
+        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()));
+
+    // Pre-populate the whitelist with mint_addr
+    mock_set_mint_whitelist_auth(&setup, &setup.sc_manager, &controller, &mint_addr, true);
+    sc_client.set_mint_whitelist(&setup.sc_manager, &controller, &mint_addr, &true);
+
+    // Now remove it
+    mock_set_mint_whitelist_auth(&setup, &setup.sc_manager, &controller, &mint_addr, false);
+    sc_client.set_mint_whitelist(&setup.sc_manager, &controller, &mint_addr, &false);
+
+    // Verify event
+    let expected =
+        MintWhitelistSet { supply_controller: controller.clone(), mint_address: mint_addr.clone(), active: false };
+    assert_eq_event(&setup.env, &setup.sac_manager, expected);
+
+    // Verify whitelist updated
+    assert!(!sc_client.is_address_whitelisted(&controller, &mint_addr));
+}
+
+#[test]
+fn test_set_mint_whitelist_remove_fails_if_not_in_whitelist() {
+    let setup = TestSetup::new().build();
+    let controller = setup.generate_address();
+    let not_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: 0 },
+        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()));
+
+    mock_set_mint_whitelist_auth(&setup, &setup.sc_manager, &controller, &not_whitelisted, false);
+    let result = sc_client.try_set_mint_whitelist(&setup.sc_manager, &controller, &not_whitelisted, &false);
+    assert_eq!(result.err().unwrap().unwrap(), SupplyControlError::NotFound.into());
+
+    // Verify whitelist remains unchanged after failed update.
+    assert!(!sc_client.is_address_whitelisted(&controller, &not_whitelisted));
+}
+
+#[test]
+fn test_set_mint_whitelist_remove_by_non_manager_fails() {
+    let setup = TestSetup::new().build();
+    let non_manager = setup.generate_address();
+    let controller = setup.generate_address();
+    let mint_addr = 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: 0 },
+        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));
+
+    // Pre-populate the whitelist with mint_addr
+    mock_set_mint_whitelist_auth(&setup, &setup.sc_manager, &controller, &mint_addr, true);
+    sc_client.set_mint_whitelist(&setup.sc_manager, &controller, &mint_addr, &true);
+
+    // Non-manager tries to remove — should fail
+    mock_set_mint_whitelist_auth(&setup, &non_manager, &controller, &mint_addr, false);
+    let result = sc_client.try_set_mint_whitelist(&non_manager, &controller, &mint_addr, &false);
+    assert_eq!(result.err().unwrap().unwrap(), SupplyControlError::Unauthorized.into());
+}
+
+#[test]
+fn test_set_mint_whitelist_fails_if_supply_controller_not_found() {
+    let setup = TestSetup::new().build();
+    let non_controller = setup.generate_address();
+    let mint_addr = setup.generate_address();
+    let sc_client = SupplyControlClient::new(&setup.env, &setup.sac_manager);
+
+    mock_set_mint_whitelist_auth(&setup, &setup.sc_manager, &non_controller, &mint_addr, true);
+    let result = sc_client.try_set_mint_whitelist(&setup.sc_manager, &non_controller, &mint_addr, &true);
+    assert_eq!(result.err().unwrap().unwrap(), SupplyControlError::NotFound.into());
+}
+
+#[test]
+fn test_set_mint_whitelist_preserves_limit_and_allow_any() {
+    let setup = TestSetup::new().build();
+    let controller = setup.generate_address();
+    let mint_addr = 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: 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_mint_whitelist_auth(&setup, &setup.sc_manager, &controller, &mint_addr, true);
+    sc_client.set_mint_whitelist(&setup.sc_manager, &controller, &mint_addr, &true);
+
+    let stored = sc_client.get_supply_controller_config(&controller).unwrap();
+    assert_eq!(stored.limit_config, config.limit_config);
+    assert_eq!(stored.allow_any_mint_burn, config.allow_any_mint_burn);
+    assert!(sc_client.is_address_whitelisted(&controller, &mint_addr));
+}
+
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_set_mint_whitelist_remove_without_auth() {
+    let setup = TestSetup::new().build();
+    let controller = setup.generate_address();
+    let mint_addr = 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: 0 },
+        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()));
+
+    // Pre-populate the whitelist with mint_addr
+    mock_set_mint_whitelist_auth(&setup, &setup.sc_manager, &controller, &mint_addr, true);
+    sc_client.set_mint_whitelist(&setup.sc_manager, &controller, &mint_addr, &true);
+
+    // sc_manager's auth is not mocked — sender.require_auth() fails
+    sc_client.set_mint_whitelist(&setup.sc_manager, &controller, &mint_addr, &false);
+}