@layerzerolabs/protocol-stellar-v2 0.2.121 → 0.2.122

package/contracts/macro-integration-tests/tests/runtime/ownable/ownership_transfer.rs

@@ -1,170 +0,0 @@
-// Runtime tests: Ownership transfer and renounce behavior.
-//
-// Tests covered:
-// - `transfer_ownership` requires current owner authorization.
-// - `renounce_ownership` clears owner and blocks further operations.
-
-use super::{TestContract, TestContractClient};
-use soroban_sdk::{
-    testutils::{Address as _, MockAuth, MockAuthInvoke},
-    xdr::{ScErrorCode, ScErrorType},
-    Address, Env, Error, IntoVal,
-};
-use utils::errors::{AuthError, OwnableError};
-use utils::ownable::{OwnershipRenounced, OwnershipTransferred};
-use utils::testing_utils::assert_eq_event;
-
-#[test]
-fn transfer_requires_auth() {
-    let env = Env::default();
-    let contract_id = env.register(TestContract, ());
-    let client = TestContractClient::new(&env, &contract_id);
-
-    let owner = Address::generate(&env);
-    let new_owner = Address::generate(&env);
-    let third_owner = Address::generate(&env);
-
-    client.init(&owner);
-
-    // Unauthorized transfer should fail
-    let unauthorized = client.try_transfer_ownership(&new_owner);
-    assert_eq!(
-        unauthorized.unwrap_err().unwrap(),
-        Error::from_type_and_code(ScErrorType::Context, ScErrorCode::InvalidAction)
-    );
-
-    // Authorized transfer should succeed
-    client
-        .mock_auths(&[MockAuth {
-            address: &owner,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "transfer_ownership",
-                args: (&new_owner,).into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .transfer_ownership(&new_owner);
-
-    assert_eq_event(
-        &env,
-        &contract_id,
-        OwnershipTransferred { old_owner: owner.clone(), new_owner: new_owner.clone() },
-    );
-
-    // Owner should be updated
-    assert_eq!(client.owner(), Some(new_owner.clone()));
-
-    // Old owner should no longer be able to transfer ownership (even with auth).
-    let old_owner_transfer = client
-        .mock_auths(&[MockAuth {
-            address: &owner,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "transfer_ownership",
-                args: (&third_owner,).into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .try_transfer_ownership(&third_owner);
-    assert_eq!(
-        old_owner_transfer.unwrap_err().unwrap(),
-        Error::from_type_and_code(ScErrorType::Context, ScErrorCode::InvalidAction)
-    );
-
-    // New owner can transfer again.
-    client
-        .mock_auths(&[MockAuth {
-            address: &new_owner,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "transfer_ownership",
-                args: (&third_owner,).into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .transfer_ownership(&third_owner);
-
-    assert_eq_event(
-        &env,
-        &contract_id,
-        OwnershipTransferred { old_owner: new_owner.clone(), new_owner: third_owner.clone() },
-    );
-    assert_eq!(client.owner(), Some(third_owner));
-}
-
-#[test]
-fn renounce_clears_owner() {
-    let env = Env::default();
-    let contract_id = env.register(TestContract, ());
-    let client = TestContractClient::new(&env, &contract_id);
-
-    let owner = Address::generate(&env);
-    let not_owner = Address::generate(&env);
-    client.init(&owner);
-    assert_eq!(client.owner(), Some(owner.clone()));
-
-    // Unauthorized renounce should fail
-    let unauthorized = client.try_renounce_ownership();
-    assert_eq!(
-        unauthorized.unwrap_err().unwrap(),
-        Error::from_type_and_code(ScErrorType::Context, ScErrorCode::InvalidAction)
-    );
-
-    // Wrong-address auth should also fail (auth must be provided by the current owner).
-    let wrong_auth = client
-        .mock_auths(&[MockAuth {
-            address: &not_owner,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "renounce_ownership",
-                args: ().into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .try_renounce_ownership();
-    assert_eq!(
-        wrong_auth.unwrap_err().unwrap(),
-        Error::from_type_and_code(ScErrorType::Context, ScErrorCode::InvalidAction)
-    );
-
-    // Renounce ownership (authorized by current owner)
-    client
-        .mock_auths(&[MockAuth {
-            address: &owner,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "renounce_ownership",
-                args: ().into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .renounce_ownership();
-
-    assert_eq_event(&env, &contract_id, OwnershipRenounced { old_owner: owner.clone() });
-
-    // Owner should be None after renouncing
-    assert_eq!(client.owner(), None);
-
-    // Renouncing again should fail because there is no owner anymore.
-    assert_eq!(client.try_renounce_ownership().unwrap_err().unwrap(), OwnableError::OwnerNotSet.into());
-
-    // All owner-protected operations should now fail
-    let guarded_result = client
-        .mock_auths(&[MockAuth {
-            address: &owner,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "guarded",
-                args: ().into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .try_guarded();
-    assert_eq!(guarded_result.unwrap_err().unwrap(), AuthError::AuthorizerNotFound.into());
-
-    assert_eq!(
-        client.try_transfer_ownership(&Address::generate(&env)).unwrap_err().unwrap(),
-        OwnableError::OwnerNotSet.into()
-    );
-}

package/contracts/macro-integration-tests/tests/runtime/ownable/two_step_transfer.rs

@@ -1,221 +0,0 @@
-// Runtime tests: 2-step ownership transfer behavior (`begin_ownership_transfer` + `accept_ownership`).
-//
-// Ownable supports a safer two-step flow using temporary storage with TTL. These tests ensure
-// the macro-exported contract entrypoints are wired and behave correctly at runtime.
-
-use super::{TestContract, TestContractClient};
-use soroban_sdk::{
-    testutils::{storage::Temporary as _, Address as _, Ledger as _, MockAuth, MockAuthInvoke},
-    Address, Env, IntoVal,
-};
-use utils::errors::OwnableError;
-use utils::ownable::{OwnableStorage, OwnershipTransferred, OwnershipTransferring};
-use utils::testing_utils::assert_eq_event;
-
-#[test]
-fn propose_requires_owner_auth() {
-    let env = Env::default();
-    let contract_id = env.register(TestContract, ());
-    let client = TestContractClient::new(&env, &contract_id);
-
-    let owner = Address::generate(&env);
-    let new_owner = Address::generate(&env);
-    client.init(&owner);
-
-    // No auth provided -> should fail at require_auth.
-    let ttl = 10u32;
-    let res = client.try_begin_ownership_transfer(&new_owner, &ttl);
-    assert_eq!(
-        res.err().unwrap().ok().unwrap(),
-        soroban_sdk::Error::from_type_and_code(
-            soroban_sdk::xdr::ScErrorType::Context,
-            soroban_sdk::xdr::ScErrorCode::InvalidAction
-        )
-    );
-}
-
-#[test]
-fn propose_rejects_invalid_ttl() {
-    let env = Env::default();
-    let contract_id = env.register(TestContract, ());
-    let client = TestContractClient::new(&env, &contract_id);
-
-    let owner = Address::generate(&env);
-    let new_owner = Address::generate(&env);
-    client.init(&owner);
-
-    let ttl = env.storage().max_ttl().saturating_add(1);
-    let res = client
-        .mock_auths(&[MockAuth {
-            address: &owner,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "begin_ownership_transfer",
-                args: (&new_owner, &ttl).into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .try_begin_ownership_transfer(&new_owner, &ttl);
-    assert_eq!(res.err().unwrap().ok().unwrap(), OwnableError::InvalidTtl.into());
-    assert_eq!(client.pending_owner(), None);
-}
-
-#[test]
-fn propose_and_accept_transfers_ownership() {
-    let env = Env::default();
-    let contract_id = env.register(TestContract, ());
-    let client = TestContractClient::new(&env, &contract_id);
-
-    let owner = Address::generate(&env);
-    let new_owner = Address::generate(&env);
-    client.init(&owner);
-
-    // Propose transfer (owner auth required).
-    let ttl = 10u32;
-    client
-        .mock_auths(&[MockAuth {
-            address: &owner,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "begin_ownership_transfer",
-                args: (&new_owner, &ttl).into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .begin_ownership_transfer(&new_owner, &ttl);
-
-    assert_eq_event(
-        &env,
-        &contract_id,
-        OwnershipTransferring { old_owner: owner.clone(), new_owner: new_owner.clone(), ttl },
-    );
-    assert_eq!(client.pending_owner(), Some(new_owner.clone()));
-    assert_eq!(client.owner(), Some(owner.clone()));
-
-    // Accept transfer (pending owner auth required).
-    client
-        .mock_auths(&[MockAuth {
-            address: &new_owner,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "accept_ownership",
-                args: ().into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .accept_ownership();
-
-    assert_eq_event(
-        &env,
-        &contract_id,
-        OwnershipTransferred { old_owner: owner.clone(), new_owner: new_owner.clone() },
-    );
-    assert_eq!(client.pending_owner(), None);
-    assert_eq!(client.owner(), Some(new_owner));
-}
-
-#[test]
-fn pending_transfer_blocks_single_step_transfer_and_renounce() {
-    let env = Env::default();
-    let contract_id = env.register(TestContract, ());
-    let client = TestContractClient::new(&env, &contract_id);
-
-    let owner = Address::generate(&env);
-    let pending = Address::generate(&env);
-    let other = Address::generate(&env);
-    client.init(&owner);
-
-    let ttl = 10u32;
-    client
-        .mock_auths(&[MockAuth {
-            address: &owner,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "begin_ownership_transfer",
-                args: (&pending, &ttl).into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .begin_ownership_transfer(&pending, &ttl);
-
-    // With owner auth, immediate transfer should fail due to TransferInProgress.
-    let transfer = client
-        .mock_auths(&[MockAuth {
-            address: &owner,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "transfer_ownership",
-                args: (&other,).into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .try_transfer_ownership(&other);
-    assert_eq!(transfer.err().unwrap().ok().unwrap(), OwnableError::TransferInProgress.into());
-
-    // With owner auth, renounce should also fail due to TransferInProgress.
-    let renounce = client
-        .mock_auths(&[MockAuth {
-            address: &owner,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "renounce_ownership",
-                args: ().into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .try_renounce_ownership();
-    assert_eq!(renounce.err().unwrap().ok().unwrap(), OwnableError::TransferInProgress.into());
-}
-
-#[test]
-fn pending_transfer_expires_and_cannot_be_accepted() {
-    let env = Env::default();
-    let contract_id = env.register(TestContract, ());
-    let client = TestContractClient::new(&env, &contract_id);
-
-    let owner = Address::generate(&env);
-    let pending = Address::generate(&env);
-    client.init(&owner);
-
-    let ttl = 1u32;
-    client
-        .mock_auths(&[MockAuth {
-            address: &owner,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "begin_ownership_transfer",
-                args: (&pending, &ttl).into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .begin_ownership_transfer(&pending, &ttl);
-
-    assert_eq!(client.pending_owner(), Some(pending.clone()));
-
-    // Advance beyond the pending owner's *actual* temporary TTL so it expires.
-    // Note: `extend_ttl` does not shrink TTL, so `ttl` is not guaranteed to be the TTL.
-    let (pending_ttl, seq) = env.as_contract(&contract_id, || {
-        (env.storage().temporary().get_ttl(&OwnableStorage::PendingOwner), env.ledger().sequence())
-    });
-    let live_until = seq + pending_ttl;
-    env.ledger().set_sequence_number(live_until + 1);
-
-    assert_eq!(client.pending_owner(), None);
-
-    // Even with pending-owner auth, accept should fail because the transfer expired.
-    let res = client
-        .mock_auths(&[MockAuth {
-            address: &pending,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "accept_ownership",
-                args: ().into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .try_accept_ownership();
-    assert_eq!(res.err().unwrap().ok().unwrap(), OwnableError::NoPendingTransfer.into());
-
-    // Owner should remain unchanged.
-    assert_eq!(client.owner(), Some(owner));
-}

package/contracts/macro-integration-tests/tests/runtime/rbac/guard_behavior.rs

@@ -1,91 +0,0 @@
-use super::{TestContract, TestContractClient};
-use soroban_sdk::{
-    testutils::{Address as _, MockAuth, MockAuthInvoke},
-    xdr::{ScErrorCode, ScErrorType},
-    Address, Env, Error, IntoVal,
-};
-
-#[test]
-fn has_role_allows_member_and_rejects_non_member() {
-    let env = Env::default();
-    let contract_id = env.register(TestContract, ());
-    let client = TestContractClient::new(&env, &contract_id);
-
-    let admin = Address::generate(&env);
-    let minter = Address::generate(&env);
-    let other = Address::generate(&env);
-
-    client.init(&admin, &minter);
-
-    // Member call should succeed.
-    client.has_role_guarded(&minter);
-
-    // Non-member call should fail with RBAC Unauthorized.
-    let res = client.try_has_role_guarded(&other);
-    assert_eq!(res.err().unwrap().ok().unwrap(), utils::errors::RbacError::Unauthorized.into());
-}
-
-#[test]
-fn only_role_enforces_require_auth_and_role_membership() {
-    let env = Env::default();
-    let contract_id = env.register(TestContract, ());
-    let client = TestContractClient::new(&env, &contract_id);
-
-    let admin = Address::generate(&env);
-    let minter = Address::generate(&env);
-    let other = Address::generate(&env);
-
-    client.init(&admin, &minter);
-
-    // 1) Role holder without auth should fail at `require_auth()`.
-    let no_auth = client.try_only_role_guarded(&minter);
-    assert_eq!(
-        no_auth.unwrap_err().unwrap(),
-        Error::from_type_and_code(ScErrorType::Context, ScErrorCode::InvalidAction)
-    );
-
-    // 2) With auth but role missing, should fail with RBAC Unauthorized.
-    let missing_role_with_auth = client
-        .mock_auths(&[MockAuth {
-            address: &other,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "only_role_guarded",
-                args: (&other,).into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .try_only_role_guarded(&other);
-    assert_eq!(missing_role_with_auth.err().unwrap().ok().unwrap(), utils::errors::RbacError::Unauthorized.into());
-
-    // 3) With auth + role, should succeed.
-    client
-        .mock_auths(&[MockAuth {
-            address: &minter,
-            invoke: &MockAuthInvoke {
-                contract: &contract_id,
-                fn_name: "only_role_guarded",
-                args: (&minter,).into_val(&env),
-                sub_invokes: &[],
-            },
-        }])
-        .only_role_guarded(&minter);
-}
-
-#[test]
-fn only_role_checks_role_before_require_auth() {
-    let env = Env::default();
-    let contract_id = env.register(TestContract, ());
-    let client = TestContractClient::new(&env, &contract_id);
-
-    let admin = Address::generate(&env);
-    let minter = Address::generate(&env);
-    let other = Address::generate(&env);
-
-    client.init(&admin, &minter);
-
-    // No auth, no role: current macro expansion checks role first, so this should
-    // return RBAC Unauthorized (not an auth error).
-    let res = client.try_only_role_guarded(&other);
-    assert_eq!(res.err().unwrap().ok().unwrap(), utils::errors::RbacError::Unauthorized.into());
-}

package/contracts/macro-integration-tests/tests/runtime/rbac/mod.rs

@@ -1,30 +0,0 @@
-use soroban_sdk::{contract, contractimpl, Address, Env, Symbol};
-
-mod guard_behavior;
-
-const MINTER_ROLE: &str = "minter";
-
-#[contract]
-pub struct TestContract;
-
-#[contractimpl]
-impl TestContract {
-    /// Test helper to deterministically grant the minter role to `minter`.
-    ///
-    /// This is intentionally unguarded; it is only used in integration tests.
-    pub fn init(env: Env, admin: Address, minter: Address) {
-        let role = Symbol::new(&env, MINTER_ROLE);
-        utils::rbac::grant_role_no_auth(&env, &minter, &role, &admin);
-    }
-
-    #[common_macros::has_role(caller, MINTER_ROLE)]
-    pub fn has_role_guarded(env: &Env, caller: Address) {
-        let _ = (env, caller);
-    }
-
-    #[common_macros::only_role(caller, MINTER_ROLE)]
-    pub fn only_role_guarded(env: &Env, caller: Address) {
-        let _ = (env, caller);
-    }
-}
-