@layerzerolabs/protocol-stellar-v2 0.2.40 → 0.2.43

package/contracts/oapps/oft/src/tests/extensions/oft_fee.rs

@@ -1,13 +1,15 @@
 extern crate std;
 
 use crate::extensions::oft_fee::{OFTFee, OFTFeeError, OFTFeeInternal};
+use crate::extensions::oft_fee::FEE_ADMIN_ROLE;
 use soroban_sdk::{
     contract, contractimpl,
     testutils::{Address as _, MockAuth, MockAuthInvoke},
     token::{StellarAssetClient, TokenClient},
-    Address, Env, IntoVal,
+    Address, Env, IntoVal, Symbol,
 };
 use utils::auth::Auth;
+use utils::rbac::{grant_role_no_auth, RoleBasedAccessControl};
 
 // ============================================================================
 // Test Contract
@@ -27,8 +29,17 @@ impl OFTFeeInternal for FeeTestContract {}
 #[contractimpl(contracttrait)]
 impl OFTFee for FeeTestContract {}
 
+#[contractimpl(contracttrait)]
+impl RoleBasedAccessControl for FeeTestContract {}
+
 #[contractimpl]
 impl FeeTestContract {
+    /// Test-only: grants FEE_ADMIN_ROLE to the contract.
+    pub fn init_roles(env: Env) {
+        let contract_id = env.current_contract_address();
+        grant_role_no_auth(&env, &contract_id, &Symbol::new(&env, FEE_ADMIN_ROLE), &contract_id);
+    }
+
     pub fn fee_view(env: Env, dst_eid: u32, amount_ld: i128) -> i128 {
         <Self as OFTFeeInternal>::__fee_view(&env, dst_eid, amount_ld)
     }
@@ -59,6 +70,7 @@ fn setup() -> TestSetup {
 
     let contract_id = env.register(FeeTestContract, ());
     let client = FeeTestContractClient::new(&env, &contract_id);
+    client.init_roles();
 
     let token_admin = Address::generate(&env);
     let sac = env.register_stellar_asset_contract_v2(token_admin.clone());
@@ -94,9 +106,9 @@ fn test_fee_deposit_address_returns_none_when_unset() {
 
 #[test]
 fn test_fee_view_nonzero_fee_errors_when_deposit_address_unset() {
-    let TestSetup { client, .. } = setup();
+    let TestSetup { client, contract_id, .. } = setup();
 
-    client.set_default_fee_bps(&Some(100u32));
+    client.set_default_fee_bps(&Some(100u32), &contract_id);
 
     let res = client.try_fee_view(&7u32, &1_000_000i128);
     assert_eq!(res.err().unwrap().ok().unwrap(), OFTFeeError::InvalidFeeDepositAddress.into());
@@ -108,29 +120,29 @@ fn test_fee_view_nonzero_fee_errors_when_deposit_address_unset() {
 
 #[test]
 fn test_set_default_fee_bps_rejects_invalid_value() {
-    let TestSetup { client, .. } = setup();
+    let TestSetup { client, contract_id, .. } = setup();
 
     // Zero is not a valid default fee (use None to remove instead)
-    let res = client.try_set_default_fee_bps(&Some(0u32));
+    let res = client.try_set_default_fee_bps(&Some(0u32), &contract_id);
     assert_eq!(res.err().unwrap().ok().unwrap(), OFTFeeError::InvalidFeeBps.into());
 
     // Exceeds maximum
-    let res = client.try_set_default_fee_bps(&Some(10_001u32));
+    let res = client.try_set_default_fee_bps(&Some(10_001u32), &contract_id);
     assert_eq!(res.err().unwrap().ok().unwrap(), OFTFeeError::InvalidFeeBps.into());
 }
 
 #[test]
 fn test_set_default_fee_bps_rejects_same_value() {
-    let TestSetup { client, .. } = setup();
+    let TestSetup { client, contract_id, .. } = setup();
 
     // None when already None (not set)
     let none: Option<u32> = None;
-    let res = client.try_set_default_fee_bps(&none);
+    let res = client.try_set_default_fee_bps(&none, &contract_id);
     assert_eq!(res.err().unwrap().ok().unwrap(), OFTFeeError::SameValue.into());
 
     // Same value when already set
-    client.set_default_fee_bps(&Some(123u32));
-    let res2 = client.try_set_default_fee_bps(&Some(123u32));
+    client.set_default_fee_bps(&Some(123u32), &contract_id);
+    let res2 = client.try_set_default_fee_bps(&Some(123u32), &contract_id);
     assert_eq!(res2.err().unwrap().ok().unwrap(), OFTFeeError::SameValue.into());
 }
 
@@ -140,27 +152,27 @@ fn test_set_default_fee_bps_rejects_same_value() {
 
 #[test]
 fn test_set_fee_bps_rejects_invalid_and_same_value() {
-    let TestSetup { client, .. } = setup();
+    let TestSetup { client, contract_id, .. } = setup();
     let dst_eid = 101u32;
 
-    let res = client.try_set_fee_bps(&dst_eid, &None);
+    let res = client.try_set_fee_bps(&dst_eid, &None, &contract_id);
     assert_eq!(res.err().unwrap().ok().unwrap(), OFTFeeError::SameValue.into());
 
-    let res2 = client.try_set_fee_bps(&dst_eid, &Some(10_001u32));
+    let res2 = client.try_set_fee_bps(&dst_eid, &Some(10_001u32), &contract_id);
     assert_eq!(res2.err().unwrap().ok().unwrap(), OFTFeeError::InvalidFeeBps.into());
 }
 
 #[test]
 fn test_set_fee_bps_set_and_remove() {
-    let TestSetup { client, .. } = setup();
+    let TestSetup { client, contract_id, .. } = setup();
     let dst_eid = 101u32;
 
-    client.set_fee_bps(&dst_eid, &Some(200u32));
+    client.set_fee_bps(&dst_eid, &Some(200u32), &contract_id);
     assert_eq!(client.fee_bps(&dst_eid), Some(200u32));
     assert_eq!(client.effective_fee_bps(&dst_eid), 200u32);
 
-    client.set_default_fee_bps(&Some(111u32));
-    client.set_fee_bps(&dst_eid, &None);
+    client.set_default_fee_bps(&Some(111u32), &contract_id);
+    client.set_fee_bps(&dst_eid, &None, &contract_id);
     assert_eq!(client.fee_bps(&dst_eid), None);
     assert_eq!(client.effective_fee_bps(&dst_eid), 111u32);
 }
@@ -195,19 +207,19 @@ fn test_charge_fee_errors_without_deposit_address() {
 
 #[test]
 fn test_set_fee_deposit_address_same_value() {
-    let TestSetup { client, fee_deposit, .. } = setup();
+    let TestSetup { client, contract_id, fee_deposit, .. } = setup();
 
     let fee_deposit_opt = Some(fee_deposit);
-    client.set_fee_deposit_address(&fee_deposit_opt);
-    let res = client.try_set_fee_deposit_address(&fee_deposit_opt);
+    client.set_fee_deposit_address(&fee_deposit_opt, &contract_id);
+    let res = client.try_set_fee_deposit_address(&fee_deposit_opt, &contract_id);
     assert_eq!(res.err().unwrap().ok().unwrap(), OFTFeeError::SameValue.into());
 }
 
 #[test]
 fn test_charge_fee_zero_amount_no_transfer() {
-    let TestSetup { env, client, token, from, fee_deposit, .. } = setup();
+    let TestSetup { env, client, contract_id, token, from, fee_deposit, .. } = setup();
 
-    client.set_fee_deposit_address(&Some(fee_deposit.clone()));
+    client.set_fee_deposit_address(&Some(fee_deposit.clone()), &contract_id);
 
     let token_client = TokenClient::new(&env, &token);
     let from_before = token_client.balance(&from);
@@ -222,9 +234,9 @@ fn test_charge_fee_zero_amount_no_transfer() {
 
 #[test]
 fn test_charge_fee_transfers() {
-    let TestSetup { env, client, token, from, fee_deposit, .. } = setup();
+    let TestSetup { env, client, contract_id, token, from, fee_deposit, .. } = setup();
 
-    client.set_fee_deposit_address(&Some(fee_deposit.clone()));
+    client.set_fee_deposit_address(&Some(fee_deposit.clone()), &contract_id);
 
     let token_client = TokenClient::new(&env, &token);
     let from_before = token_client.balance(&from);
@@ -238,10 +250,10 @@ fn test_charge_fee_transfers() {
 
 #[test]
 fn test_fee_view_computes_correct_fee() {
-    let TestSetup { client, fee_deposit, .. } = setup();
+    let TestSetup { client, contract_id, fee_deposit, .. } = setup();
 
-    client.set_fee_deposit_address(&Some(fee_deposit));
-    client.set_default_fee_bps(&Some(100u32)); // 1%
+    client.set_fee_deposit_address(&Some(fee_deposit), &contract_id);
+    client.set_default_fee_bps(&Some(100u32), &contract_id); // 1%
 
     let fee = client.fee_view(&999u32, &10_000i128);
     assert_eq!(fee, 100); // 1% of 10,000

package/contracts/oapps/oft/src/tests/extensions/pausable.rs

@@ -1,7 +1,9 @@
 extern crate std;
 
 use crate::extensions::pausable::{OFTPausable, OFTPausableError, OFTPausableInternal};
-use soroban_sdk::{contract, contractimpl, Address, Env};
+use crate::extensions::pausable::{PAUSER_ROLE, UNPAUSER_ROLE};
+use soroban_sdk::{contract, contractimpl, Address, Env, Symbol};
+use utils::rbac::{grant_role_no_auth, RoleBasedAccessControl};
 use utils::auth::Auth;
 
 // ============================================================================
@@ -22,8 +24,18 @@ impl OFTPausableInternal for PausableTestContract {}
 #[contractimpl(contracttrait)]
 impl OFTPausable for PausableTestContract {}
 
+#[contractimpl(contracttrait)]
+impl RoleBasedAccessControl for PausableTestContract {}
+
 #[contractimpl]
 impl PausableTestContract {
+    /// Test-only: grants PAUSER_ROLE and UNPAUSER_ROLE to the contract.
+    pub fn init_roles(env: Env) {
+        let contract_id = env.current_contract_address();
+        grant_role_no_auth(&env, &contract_id, &Symbol::new(&env, PAUSER_ROLE), &contract_id);
+        grant_role_no_auth(&env, &contract_id, &Symbol::new(&env, UNPAUSER_ROLE), &contract_id);
+    }
+
     pub fn assert_not_paused(env: Env) {
         <Self as OFTPausableInternal>::__assert_not_paused(&env)
     }
@@ -35,6 +47,7 @@ impl PausableTestContract {
 
 struct TestSetup {
     client: PausableTestContractClient<'static>,
+    contract_id: Address,
 }
 
 fn setup() -> TestSetup {
@@ -43,7 +56,8 @@ fn setup() -> TestSetup {
 
     let contract_id = env.register(PausableTestContract, ());
     let client = PausableTestContractClient::new(&env, &contract_id);
-    TestSetup { client }
+    client.init_roles();
+    TestSetup { client, contract_id }
 }
 
 // ============================================================================
@@ -58,45 +72,45 @@ fn test_initial_state_is_not_paused() {
 }
 
 // ============================================================================
-// Set Paused Tests
+// Pause/Unpause Tests
 // ============================================================================
 
 #[test]
-fn test_set_paused_to_true() {
-    let TestSetup { client, .. } = setup();
+fn test_pause_sets_paused() {
+    let TestSetup { client, contract_id, .. } = setup();
 
-    client.set_paused(&true);
+    client.pause(&contract_id);
     assert!(client.is_paused());
 }
 
 #[test]
-fn test_set_paused_to_false_after_pausing() {
-    let TestSetup { client, .. } = setup();
+fn test_unpause_after_pausing() {
+    let TestSetup { client, contract_id, .. } = setup();
 
-    client.set_paused(&true);
+    client.pause(&contract_id);
     assert!(client.is_paused());
 
-    client.set_paused(&false);
+    client.unpause(&contract_id);
     assert!(!client.is_paused());
 }
 
 #[test]
-fn test_set_paused_rejects_same_value_when_unpaused() {
-    let TestSetup { client, .. } = setup();
+fn test_unpause_unchanged_when_unpaused() {
+    let TestSetup { client, contract_id, .. } = setup();
 
-    // Initially not paused, setting to false should fail
-    let res = client.try_set_paused(&false);
+    // Initially not paused, unpause should fail
+    let res = client.try_unpause(&contract_id);
     assert_eq!(res.err().unwrap().ok().unwrap(), OFTPausableError::PauseStatusUnchanged.into());
 }
 
 #[test]
-fn test_set_paused_rejects_same_value_when_paused() {
-    let TestSetup { client, .. } = setup();
+fn test_pause_unchanged_when_paused() {
+    let TestSetup { client, contract_id, .. } = setup();
 
-    client.set_paused(&true);
+    client.pause(&contract_id);
 
-    // Already paused, setting to true should fail
-    let res = client.try_set_paused(&true);
+    // Already paused, pause again should fail
+    let res = client.try_pause(&contract_id);
     assert_eq!(res.err().unwrap().ok().unwrap(), OFTPausableError::PauseStatusUnchanged.into());
 }
 
@@ -114,9 +128,9 @@ fn test_assert_not_paused_succeeds_when_not_paused() {
 
 #[test]
 fn test_assert_not_paused_fails_when_paused() {
-    let TestSetup { client, .. } = setup();
+    let TestSetup { client, contract_id, .. } = setup();
 
-    client.set_paused(&true);
+    client.pause(&contract_id);
 
     let res = client.try_assert_not_paused();
     assert_eq!(res.err().unwrap().ok().unwrap(), OFTPausableError::Paused.into());
@@ -128,14 +142,14 @@ fn test_assert_not_paused_fails_when_paused() {
 
 #[test]
 fn test_pause_unpause_toggle_multiple_times() {
-    let TestSetup { client, .. } = setup();
+    let TestSetup { client, contract_id, .. } = setup();
 
     // Toggle multiple times
     for _ in 0..3 {
         assert!(!client.is_paused());
-        client.set_paused(&true);
+        client.pause(&contract_id);
         assert!(client.is_paused());
-        client.set_paused(&false);
+        client.unpause(&contract_id);
     }
     assert!(!client.is_paused());
 }