@layerzerolabs/protocol-stellar-v2 0.2.29 → 0.2.30

package/contracts/sac-manager/src/tests/sac_manager/mint.rs

@@ -0,0 +1,252 @@
+//! Mint (MintBurnable) Integration Tests
+
+use super::test_helper::{mock_set_authorized_auth, mock_set_mint_whitelist_auth, mock_set_supply_controller_auth};
+use crate::errors::SacManagerError;
+use crate::extensions::redistribution::RedistributeFunds;
+use crate::extensions::supply_control::{LimitConfig, SupplyControlError, SupplyControllerConfig};
+use crate::tests::test_helper::{mock_oft_mint_auth, TestSetup};
+use soroban_sdk::{testutils::IssuerFlags, Vec};
+use utils::testing_utils::assert_contains_event;
+
+// =========================================================================
+// Mint Tests (without Supply Control) — OFT calls mint
+// =========================================================================
+
+#[test]
+fn test_mint_by_oft() {
+    let setup = TestSetup::new().with_manager_as_sac_admin().build();
+    let recipient = setup.generate_address();
+
+    // Supply control is disabled by default
+    assert!(!setup.sac_manager_client.supply_control_enabled());
+
+    // OFT can mint when supply control is disabled (no SupplyIncreased event emitted)
+    mock_oft_mint_auth(&setup, &recipient, 1000_i128);
+    setup.sac_manager_client.mint(&recipient, &1000);
+    assert_eq!(setup.sac_client.balance(&recipient), 1000);
+}
+
+#[test]
+fn test_oft_mint_redistributes_when_recipient_blacklisted() {
+    let setup = TestSetup::new().with_manager_as_sac_admin().with_redistribution_enabled().build();
+    let blacklisted_recipient = setup.generate_address();
+
+    // Enable issuer flags required for blacklist behavior in SAC tests.
+    setup.sac_contract.issuer().set_flag(IssuerFlags::RevocableFlag);
+    setup.sac_contract.issuer().set_flag(IssuerFlags::ClawbackEnabledFlag);
+
+    mock_set_authorized_auth(&setup, &blacklisted_recipient, false);
+    setup.sac_manager_client.set_authorized(&blacklisted_recipient, &false);
+    assert!(!setup.sac_client.authorized(&blacklisted_recipient));
+
+    let owner_balance_before = setup.sac_client.balance(&setup.owner);
+    let blacklisted_balance_before = setup.sac_client.balance(&blacklisted_recipient);
+
+    mock_oft_mint_auth(&setup, &blacklisted_recipient, 700_i128);
+    setup.sac_manager_client.mint(&blacklisted_recipient, &700);
+
+    // No SupplyIncreased when supply control is off; only RedistributeFunds is emitted.
+    let expected = RedistributeFunds { user: blacklisted_recipient.clone(), amount: 700 };
+    assert_contains_event(&setup.env, &setup.sac_manager, expected);
+
+    assert_eq!(setup.sac_client.balance(&blacklisted_recipient), blacklisted_balance_before);
+    assert_eq!(setup.sac_client.balance(&setup.owner), owner_balance_before + 700);
+}
+
+#[test]
+fn test_mint_fails_when_oft_not_set() {
+    let setup = TestSetup::new().without_oft().build();
+    let recipient = setup.generate_address();
+
+    let result = setup.sac_manager_client.try_mint(&recipient, &1000);
+    assert_eq!(result.err().unwrap().unwrap(), SacManagerError::OftAddressNotSet.into());
+}
+
+// =========================================================================
+// Mint Tests (with Supply Control)
+// =========================================================================
+
+#[test]
+fn test_mint_within_rate_limit() {
+    let setup = TestSetup::new().with_manager_as_sac_admin().with_supply_control_enabled().build();
+    let recipient = setup.generate_address();
+
+    // Add the OFT as a supply controller
+    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, &setup.oft, &Some(config.clone()));
+    setup.sac_manager_client.set_supply_controller(&setup.sc_manager, &setup.oft, &Some(config.clone()));
+
+    // Mint within limit should succeed
+    mock_oft_mint_auth(&setup, &recipient, 500_i128);
+    setup.sac_manager_client.mint(&recipient, &500);
+    assert_eq!(setup.sac_client.balance(&recipient), 500);
+    assert_eq!(setup.sac_manager_client.get_remaining_mint_amount(&setup.oft), 500);
+}
+
+#[test]
+fn test_mint_to_whitelisted_address() {
+    let setup = TestSetup::new().with_manager_as_sac_admin().with_supply_control_enabled().build();
+    let whitelisted = setup.generate_address();
+
+    // Add OFT as controller with whitelist (NOT allow_any_mint_burn)
+    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, &setup.oft, &Some(config.clone()));
+    setup.sac_manager_client.set_supply_controller(&setup.sc_manager, &setup.oft, &Some(config.clone()));
+
+    // Add whitelisted address to the whitelist
+    mock_set_mint_whitelist_auth(&setup, &setup.sc_manager, &setup.oft, &whitelisted, true);
+    setup.sac_manager_client.set_mint_whitelist(&setup.sc_manager, &setup.oft, &whitelisted, &true);
+
+    // Mint to whitelisted address should succeed
+    mock_oft_mint_auth(&setup, &whitelisted, 500_i128);
+    setup.sac_manager_client.mint(&whitelisted, &500);
+    assert_eq!(setup.sac_client.balance(&whitelisted), 500);
+}
+
+// =========================================================================
+// Mint Error Cases (Supply Control)
+// =========================================================================
+
+#[test]
+fn test_mint_exceeds_rate_limit() {
+    let setup = TestSetup::new().with_manager_as_sac_admin().with_supply_control_enabled().build();
+    let recipient = setup.generate_address();
+
+    let config = SupplyControllerConfig {
+        limit_config: LimitConfig { limit_capacity: 100, 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()));
+    setup.sac_manager_client.set_supply_controller(&setup.sc_manager, &setup.oft, &Some(config.clone()));
+
+    // Try to mint more than limit - should fail
+    mock_oft_mint_auth(&setup, &recipient, 200_i128);
+    let result = setup.sac_manager_client.try_mint(&recipient, &200);
+    assert_eq!(result.err().unwrap().unwrap(), SupplyControlError::RateLimitExceeded.into());
+}
+
+#[test]
+fn test_mint_failure_does_not_change_remaining_amount() {
+    let setup = TestSetup::new().with_manager_as_sac_admin().with_supply_control_enabled().build();
+    let recipient = setup.generate_address();
+
+    let config = SupplyControllerConfig {
+        limit_config: LimitConfig { limit_capacity: 100, 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()));
+    setup.sac_manager_client.set_supply_controller(&setup.sc_manager, &setup.oft, &Some(config.clone()));
+
+    let remaining_before = setup.sac_manager_client.get_remaining_mint_amount(&setup.oft);
+    mock_oft_mint_auth(&setup, &recipient, 200_i128);
+    let result = setup.sac_manager_client.try_mint(&recipient, &200);
+    let remaining_after = setup.sac_manager_client.get_remaining_mint_amount(&setup.oft);
+
+    assert_eq!(result.err().unwrap().unwrap(), SupplyControlError::RateLimitExceeded.into());
+    assert_eq!(remaining_after, remaining_before);
+}
+
+#[test]
+fn test_mint_to_non_whitelisted_fails() {
+    let setup = TestSetup::new().with_manager_as_sac_admin().with_supply_control_enabled().build();
+    let whitelisted = setup.generate_address();
+    let not_whitelisted = setup.generate_address();
+
+    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, &setup.oft, &Some(config.clone()));
+    setup.sac_manager_client.set_supply_controller(&setup.sc_manager, &setup.oft, &Some(config.clone()));
+
+    // Add whitelisted address (not_whitelisted is NOT added)
+    mock_set_mint_whitelist_auth(&setup, &setup.sc_manager, &setup.oft, &whitelisted, true);
+    setup.sac_manager_client.set_mint_whitelist(&setup.sc_manager, &setup.oft, &whitelisted, &true);
+
+    // Mint to non-whitelisted address should fail
+    mock_oft_mint_auth(&setup, &not_whitelisted, 500_i128);
+    let result = setup.sac_manager_client.try_mint(&not_whitelisted, &500);
+    assert_eq!(result.err().unwrap().unwrap(), SupplyControlError::CannotMintToAddress.into());
+}
+
+#[test]
+fn test_mint_fails_when_oft_not_supply_controller() {
+    let setup = TestSetup::new().with_manager_as_sac_admin().with_supply_control_enabled().build();
+    let recipient = setup.generate_address();
+
+    // OFT is NOT added as supply controller — should fail
+    mock_oft_mint_auth(&setup, &recipient, 500_i128);
+    let result = setup.sac_manager_client.try_mint(&recipient, &500);
+    assert_eq!(result.err().unwrap().unwrap(), SupplyControlError::NotFound.into());
+
+    // Non-controller should report zero remaining mint amount.
+    assert_eq!(setup.sac_manager_client.get_remaining_mint_amount(&recipient), 0);
+}
+
+// =========================================================================
+// get_remaining_mint_amount Tests
+// =========================================================================
+
+#[test]
+fn test_unlimited_rate_limit() {
+    let setup = TestSetup::new().with_manager_as_sac_admin().build();
+
+    // refill_per_second == 0 means unlimited
+    let config = SupplyControllerConfig {
+        limit_config: LimitConfig { limit_capacity: 1_000, refill_per_second: 0 },
+        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()));
+    setup.sac_manager_client.set_supply_controller(&setup.sc_manager, &setup.oft, &Some(config.clone()));
+
+    let remaining = setup.sac_manager_client.get_remaining_mint_amount(&setup.oft);
+    assert_eq!(remaining, i128::MAX);
+}
+
+#[test]
+fn test_mint_exact_capacity_then_next_fails() {
+    let setup = TestSetup::new().with_manager_as_sac_admin().with_supply_control_enabled().build();
+    let recipient = setup.generate_address();
+
+    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()));
+    setup.sac_manager_client.set_supply_controller(&setup.sc_manager, &setup.oft, &Some(config.clone()));
+
+    mock_oft_mint_auth(&setup, &recipient, 1000_i128);
+    setup.sac_manager_client.mint(&recipient, &1000);
+    assert_eq!(setup.sac_manager_client.get_remaining_mint_amount(&setup.oft), 0);
+
+    mock_oft_mint_auth(&setup, &recipient, 1_i128);
+    let result = setup.sac_manager_client.try_mint(&recipient, &1);
+    assert_eq!(result.err().unwrap().unwrap(), SupplyControlError::RateLimitExceeded.into());
+}
+
+// =========================================================================
+// Mint Auth Tests
+// =========================================================================
+
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_mint_fails_without_oft_auth() {
+    // No mock_all_auths — the OFT address won't be authorized
+    let setup = TestSetup::new().with_manager_as_sac_admin().build();
+    let recipient = setup.generate_address();
+
+    setup.sac_manager_client.mint(&recipient, &1000);
+}

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

@@ -0,0 +1,9 @@
+mod clawback;
+mod admin_mint;
+mod burn;
+mod mint;
+mod set_admin;
+mod set_authorized;
+mod set_oft_address;
+mod test_helper;
+mod view_functions;

package/contracts/sac-manager/src/tests/sac_manager/set_admin.rs

@@ -0,0 +1,36 @@
+//! release_sac_admin Integration Tests
+
+use super::test_helper::mock_release_sac_admin_auth;
+use crate::tests::test_helper::TestSetup;
+
+// =========================================================================
+// release_sac_admin Tests
+// =========================================================================
+
+#[test]
+fn test_release_sac_admin() {
+    let setup = TestSetup::new().with_manager_as_sac_admin().build();
+    let new_admin = setup.generate_address();
+
+    // Current SAC admin is the manager (configured by test setup).
+    assert_eq!(setup.sac_client.admin(), setup.sac_manager);
+
+    // Owner can change SAC admin
+    mock_release_sac_admin_auth(&setup, &new_admin);
+    setup.sac_manager_client.release_sac_admin(&new_admin);
+    assert_eq!(setup.sac_client.admin(), new_admin);
+}
+
+// =========================================================================
+// release_sac_admin Auth Tests
+// =========================================================================
+
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_release_sac_admin_without_auth() {
+    let setup = TestSetup::new().build();
+    let new_admin = setup.generate_address();
+
+    // Should panic because owner doesn't authorize the call
+    setup.sac_manager_client.release_sac_admin(&new_admin);
+}

package/contracts/sac-manager/src/tests/sac_manager/set_authorized.rs

@@ -0,0 +1,43 @@
+//! set_authorized Integration Tests
+//!
+//! Requires revocable issuer flag on the SAC before authorization can be changed.
+
+use super::test_helper::mock_set_authorized_auth;
+use crate::tests::test_helper::TestSetup;
+use soroban_sdk::testutils::IssuerFlags;
+
+// =========================================================================
+// set_authorized Tests
+// =========================================================================
+
+#[test]
+fn test_set_authorized_by_owner() {
+    let setup = TestSetup::new().with_manager_as_sac_admin().build();
+    let user = setup.generate_address();
+
+    // Enable issuer flag required by SAC for set_authorized.
+    setup.sac_contract.issuer().set_flag(IssuerFlags::RevocableFlag);
+    assert!(setup.sac_client.authorized(&user));
+
+    mock_set_authorized_auth(&setup, &user, false);
+    setup.sac_manager_client.set_authorized(&user, &false);
+    assert!(!setup.sac_client.authorized(&user));
+
+    mock_set_authorized_auth(&setup, &user, true);
+    setup.sac_manager_client.set_authorized(&user, &true);
+    assert!(setup.sac_client.authorized(&user));
+}
+
+// =========================================================================
+// set_authorized Auth Tests
+// =========================================================================
+
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_set_authorized_without_auth() {
+    let setup = TestSetup::new().build();
+    let user = setup.generate_address();
+
+    // Should panic because owner doesn't authorize the call
+    setup.sac_manager_client.set_authorized(&user, &false);
+}

package/contracts/sac-manager/src/tests/sac_manager/set_oft_address.rs

@@ -0,0 +1,47 @@
+//! set_oft_address Integration Tests
+
+use super::test_helper::mock_set_oft_address_auth;
+use crate::errors::SacManagerError;
+use crate::tests::test_helper::TestSetup;
+
+// =========================================================================
+// set_oft_address Error Cases
+// =========================================================================
+
+#[test]
+fn test_set_oft_address_by_owner_when_not_set() {
+    let setup = TestSetup::new().without_oft().build();
+    let new_oft = setup.generate_address();
+
+    let initial = setup.sac_manager_client.try_oft_address();
+    assert_eq!(initial.err().unwrap().unwrap(), SacManagerError::OftAddressNotSet.into());
+
+    mock_set_oft_address_auth(&setup, &new_oft);
+    setup.sac_manager_client.set_oft_address(&new_oft);
+    assert_eq!(setup.sac_manager_client.oft_address(), new_oft);
+}
+
+#[test]
+fn test_set_oft_address_fails_if_same_value() {
+    let setup = TestSetup::new().build();
+
+    // Setting the same OFT address should fail with SameValue
+    mock_set_oft_address_auth(&setup, &setup.oft);
+    let result = setup.sac_manager_client.try_set_oft_address(&setup.oft);
+    assert_eq!(result.err().unwrap().unwrap(), SacManagerError::SameValue.into());
+}
+
+// =========================================================================
+// set_oft_address Auth Tests
+// =========================================================================
+
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_set_oft_address_without_auth() {
+    // Build without mock_all_auths and without setting OFT (to test auth, not the once-only check)
+    let setup = TestSetup::new().without_oft().build();
+    let new_oft = setup.generate_address();
+
+    // Should panic because owner doesn't authorize the call
+    setup.sac_manager_client.set_oft_address(&new_oft);
+}

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

@@ -0,0 +1,75 @@
+use crate::tests::test_helper::{mock_auth, TestSetup};
+use soroban_sdk::{
+    testutils::{MockAuth, MockAuthInvoke},
+    Address, IntoVal,
+};
+
+pub use crate::tests::test_helper::mock_set_supply_controller_auth;
+
+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_authorized_mint_auth(setup: &TestSetup, sender: &Address, recipient: &Address, amount: i128) {
+    mock_auth(&setup.env, &setup.sac_manager, sender, "authorized_mint", (sender, recipient, amount));
+}
+
+pub fn mock_clawback_auth(setup: &TestSetup, sender: &Address, from: &Address, amount: i128) {
+    mock_auth(&setup.env, &setup.sac_manager, sender, "clawback", (sender, from, amount));
+}
+
+pub fn mock_burn_auth(setup: &TestSetup, from: &Address, amount: i128) {
+    let sac_burn_sub_invoke = MockAuthInvoke {
+        contract: &setup.sac,
+        fn_name: "burn",
+        args: (from, amount).into_val(&setup.env),
+        sub_invokes: &[],
+    };
+
+    let from_sub_invokes = [sac_burn_sub_invoke];
+
+    setup.env.mock_auths(&[
+        // `from` authorizes sac_manager.burn → nested sac.burn(from, amount)
+        MockAuth {
+            address: from,
+            invoke: &MockAuthInvoke {
+                contract: &setup.sac_manager,
+                fn_name: "burn",
+                args: (from, amount).into_val(&setup.env),
+                sub_invokes: &from_sub_invokes,
+            },
+        },
+        // OFT also authorizes sac_manager.burn (no sub-invokes needed)
+        MockAuth {
+            address: &setup.oft,
+            invoke: &MockAuthInvoke {
+                contract: &setup.sac_manager,
+                fn_name: "burn",
+                args: (from, amount).into_val(&setup.env),
+                sub_invokes: &[],
+            },
+        },
+    ]);
+}
+
+pub fn mock_set_authorized_auth(setup: &TestSetup, user: &Address, authorize: bool) {
+    mock_auth(&setup.env, &setup.sac_manager, &setup.owner, "set_authorized", (user, authorize));
+}
+
+pub fn mock_release_sac_admin_auth(setup: &TestSetup, new_admin: &Address) {
+    mock_auth(&setup.env, &setup.sac_manager, &setup.owner, "release_sac_admin", (new_admin,));
+}
+
+pub fn mock_set_oft_address_auth(setup: &TestSetup, new_oft: &Address) {
+    mock_auth(&setup.env, &setup.sac_manager, &setup.owner, "set_oft_address", (new_oft,));
+}
+
+pub fn mock_sac_owner_mint_auth(setup: &TestSetup, recipient: &Address, amount: i128) {
+    mock_auth(&setup.env, &setup.sac, &setup.owner, "mint", (recipient, amount));
+}

package/contracts/sac-manager/src/tests/sac_manager/view_functions.rs

@@ -0,0 +1,60 @@
+//! View Functions Integration Tests
+
+use crate::errors::SacManagerError;
+use crate::tests::test_helper::TestSetup;
+
+// =========================================================================
+// Core View Functions
+// =========================================================================
+
+#[test]
+fn test_underlying_sac() {
+    let setup = TestSetup::new().build();
+    assert_eq!(setup.sac_manager_client.underlying_sac(), setup.sac);
+}
+
+#[test]
+fn test_oft_address() {
+    let setup = TestSetup::new().build();
+    assert_eq!(setup.sac_manager_client.oft_address(), setup.oft);
+}
+
+#[test]
+fn test_oft_address_fails_when_not_set() {
+    let setup = TestSetup::new().without_oft().build();
+
+    let result = setup.sac_manager_client.try_oft_address();
+    assert_eq!(result.err().unwrap().unwrap(), SacManagerError::OftAddressNotSet.into());
+}
+
+// =========================================================================
+// Redistribution Settings
+// =========================================================================
+
+#[test]
+fn test_redistribution_disabled_by_default() {
+    let setup = TestSetup::new().build();
+    assert!(!setup.sac_manager_client.redistribution_enabled());
+}
+
+#[test]
+fn test_redistribution_enabled_at_construction() {
+    let setup: TestSetup<'_> = TestSetup::new().with_redistribution_enabled().build();
+    assert!(setup.sac_manager_client.redistribution_enabled());
+}
+
+// =========================================================================
+// Supply Control Settings
+// =========================================================================
+
+#[test]
+fn test_supply_control_disabled_by_default() {
+    let setup = TestSetup::new().build();
+    assert!(!setup.sac_manager_client.supply_control_enabled());
+}
+
+#[test]
+fn test_supply_control_enabled_at_construction() {
+    let setup = TestSetup::new().with_supply_control_enabled().build();
+    assert!(setup.sac_manager_client.supply_control_enabled());
+}