@layerzerolabs/protocol-stellar-v2 0.2.33 → 0.2.34

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

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

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

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

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

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