@layerzerolabs/protocol-stellar-v2 0.2.19 → 0.2.21

package/contracts/oapps/oapp/src/tests/test_oapp_receiver.rs

@@ -1,153 +0,0 @@
-use crate::{
-    self as oapp, errors::OAppError, oapp_core::OAppCoreStorage, oapp_receiver::LzReceiveInternal,
-    tests::test_oapp_core::DummyEndpoint,
-};
-use endpoint_v2::Origin;
-use soroban_sdk::{assert_with_error, contractimpl, testutils::Address as _, Address, Bytes, BytesN, Env};
-use utils::option_ext::OptionExt;
-
-#[oapp_macros::oapp]
-pub struct DummyOAppReceiver;
-
-impl LzReceiveInternal for DummyOAppReceiver {
-    fn __lz_receive(
-        _env: &Env,
-        _origin: &Origin,
-        _guid: &BytesN<32>,
-        _message: &Bytes,
-        _extra_data: &Bytes,
-        _executor: &Address,
-        _value: i128,
-    ) {
-        // do nothing
-    }
-}
-
-#[contractimpl]
-impl DummyOAppReceiver {
-    pub fn __constructor(env: &Env, owner: &Address, endpoint: &Address) {
-        oapp::oapp_core::initialize_oapp::<Self>(env, owner, endpoint, &None);
-    }
-
-    pub fn assert_allowed_peer(env: &Env, origin: &Origin) {
-        let peer = OAppCoreStorage::peer(env, origin.src_eid).unwrap_or_panic(env, OAppError::NoPeer);
-        assert_with_error!(env, peer == origin.sender, OAppError::OnlyPeer);
-    }
-}
-
-const REMOTE_EID: u32 = 100;
-const UNSET_EID: u32 = 999;
-
-struct TestSetup<'a> {
-    env: Env,
-    #[allow(dead_code)]
-    owner: Address,
-    #[allow(dead_code)]
-    endpoint: Address,
-    #[allow(dead_code)]
-    native_token: Address,
-    oapp_client: DummyOAppReceiverClient<'a>,
-}
-
-fn setup<'a>() -> TestSetup<'a> {
-    let env = Env::default();
-
-    let owner = Address::generate(&env);
-    let endpoint = env.register(DummyEndpoint, ());
-    let native_token = Address::generate(&env);
-    let oapp = env.register(DummyOAppReceiver, (&owner, &endpoint));
-    let oapp_client = DummyOAppReceiverClient::new(&env, &oapp);
-    TestSetup { env, owner, endpoint, native_token, oapp_client }
-}
-
-#[test]
-fn test_is_compose_msg_sender_same_contract() {
-    let TestSetup { env, oapp_client, .. } = setup();
-
-    let origin = Origin { src_eid: REMOTE_EID, sender: BytesN::from_array(&env, &[1; 32]), nonce: 1 };
-    let message = Bytes::from_array(&env, &[1, 2, 3, 4]);
-
-    // Test with same contract address (should return true)
-    let result = oapp_client.is_compose_msg_sender(&origin, &message, &oapp_client.address);
-    assert_eq!(result, true);
-}
-
-#[test]
-fn test_is_compose_msg_sender_different_contract() {
-    let TestSetup { env, oapp_client, .. } = setup();
-
-    let origin = Origin { src_eid: REMOTE_EID, sender: BytesN::from_array(&env, &[1; 32]), nonce: 1 };
-    let message = Bytes::from_array(&env, &[1, 2, 3, 4]);
-    let different_sender = Address::generate(&env);
-
-    // Test with different sender address (should return false)
-    let result = oapp_client.is_compose_msg_sender(&origin, &message, &different_sender);
-    assert_eq!(result, false);
-}
-
-#[test]
-fn test_allow_initialize_path_with_matching_peer() {
-    let TestSetup { env, oapp_client, .. } = setup();
-    env.mock_all_auths();
-
-    let peer_bytes: BytesN<32> = BytesN::from_array(&env, &[5; 32]);
-    oapp_client.set_peer(&REMOTE_EID, &Some(peer_bytes.clone()));
-
-    let origin = Origin { src_eid: REMOTE_EID, sender: peer_bytes.clone(), nonce: 1 };
-
-    let result = oapp_client.allow_initialize_path(&origin);
-    assert_eq!(result, true);
-}
-
-#[test]
-fn test_allow_initialize_path_with_non_matching_peer() {
-    let TestSetup { env, oapp_client, .. } = setup();
-    env.mock_all_auths();
-
-    let peer_bytes: BytesN<32> = BytesN::from_array(&env, &[5; 32]);
-    oapp_client.set_peer(&REMOTE_EID, &Some(peer_bytes));
-
-    let different_sender: BytesN<32> = BytesN::from_array(&env, &[6; 32]);
-    let origin = Origin { src_eid: REMOTE_EID, sender: different_sender, nonce: 1 };
-
-    let result = oapp_client.allow_initialize_path(&origin);
-    assert_eq!(result, false);
-}
-
-#[test]
-fn test_allow_initialize_path_with_no_peer_set() {
-    let TestSetup { env, oapp_client, .. } = setup();
-
-    let origin = Origin { src_eid: UNSET_EID, sender: BytesN::from_array(&env, &[5; 32]), nonce: 1 };
-
-    let result = oapp_client.allow_initialize_path(&origin);
-    assert_eq!(result, false);
-}
-
-#[test]
-fn test_assert_allowed_peer_wrong_sender() {
-    let TestSetup { env, oapp_client, .. } = setup();
-    env.mock_all_auths();
-
-    let peer_bytes: BytesN<32> = BytesN::from_array(&env, &[7; 32]);
-    oapp_client.set_peer(&REMOTE_EID, &Some(peer_bytes));
-
-    let wrong_sender: BytesN<32> = BytesN::from_array(&env, &[8; 32]);
-    let origin = Origin { src_eid: REMOTE_EID, sender: wrong_sender, nonce: 1 };
-
-    // This should panic with OnlyPeer error
-    let result = oapp_client.try_assert_allowed_peer(&origin);
-    assert_eq!(result.err().unwrap().ok().unwrap(), OAppError::OnlyPeer.into());
-}
-
-#[test]
-fn test_assert_allowed_peer_no_peer() {
-    let TestSetup { env, oapp_client, .. } = setup();
-    env.mock_all_auths();
-
-    let origin = Origin { src_eid: UNSET_EID, sender: BytesN::from_array(&env, &[7; 32]), nonce: 1 };
-
-    // This should panic with NoPeer error
-    let result = oapp_client.try_assert_allowed_peer(&origin);
-    assert_eq!(result.err().unwrap().ok().unwrap(), OAppError::NoPeer.into());
-}

package/contracts/oapps/oapp/src/tests/test_oapp_sender.rs

@@ -1,294 +0,0 @@
-use crate::{self as oapp, errors::OAppError, oapp_receiver::LzReceiveInternal};
-use endpoint_v2::{MessagingFee, MessagingParams, MessagingReceipt, Origin};
-use soroban_sdk::{
-    contract, contractimpl, symbol_short,
-    testutils::{Address as _, MockAuth, MockAuthInvoke},
-    token::{StellarAssetClient, TokenClient},
-    Address, Bytes, BytesN, Env, IntoVal,
-};
-
-// Mock Endpoint contract
-#[contract]
-pub struct MockEndpoint;
-
-#[contractimpl]
-impl MockEndpoint {
-    pub fn __constructor(env: Env, zro_token: &Address, native_token: &Address) {
-        env.storage().instance().set(&symbol_short!("zro"), zro_token);
-        env.storage().instance().set(&symbol_short!("ntk"), native_token);
-    }
-
-    pub fn set_delegate(_env: Env, _oapp: Address, _delegate: Option<Address>) {
-        // do nothing in mock
-    }
-
-    pub fn quote(_env: Env, _sender: Address, params: MessagingParams) -> MessagingFee {
-        MessagingFee { native_fee: 1000, zro_fee: if params.pay_in_zro { 500 } else { 0 } }
-    }
-
-    pub fn send(env: Env, _sender: Address, params: MessagingParams, _refund_address: Address) -> MessagingReceipt {
-        // Return mock receipt
-        MessagingReceipt {
-            guid: BytesN::from_array(&env, &[1u8; 32]),
-            nonce: 1,
-            fee: MessagingFee { native_fee: 1000, zro_fee: if params.pay_in_zro { 500 } else { 0 } },
-        }
-    }
-
-    pub fn zro(env: Env) -> Option<Address> {
-        // Return a mock ZRO token address
-        env.storage().instance().get(&symbol_short!("zro")).unwrap()
-    }
-
-    pub fn native_token(env: Env) -> Address {
-        env.storage().instance().get(&symbol_short!("ntk")).unwrap()
-    }
-}
-
-#[oapp_macros::oapp]
-pub struct DummyOAppSender;
-
-impl LzReceiveInternal for DummyOAppSender {
-    fn __lz_receive(
-        _env: &Env,
-        _origin: &Origin,
-        _guid: &BytesN<32>,
-        _message: &Bytes,
-        _extra_data: &Bytes,
-        _executor: &Address,
-        _value: i128,
-    ) {
-        // Not used in sender tests
-    }
-}
-
-#[contractimpl]
-impl DummyOAppSender {
-    pub fn __constructor(env: &Env, owner: &Address, endpoint: &Address) {
-        oapp::oapp_core::initialize_oapp::<Self>(env, owner, endpoint, &None);
-    }
-
-    pub fn quote(env: &Env, dst_eid: u32, message: &Bytes, options: &Bytes, pay_in_zro: bool) -> MessagingFee {
-        Self::__quote(env, dst_eid, message, options, pay_in_zro)
-    }
-
-    pub fn send(
-        env: &Env,
-        sender: &Address,
-        dst_eid: u32,
-        message: &Bytes,
-        options: &Bytes,
-        fee: &MessagingFee,
-        refund_address: &Address,
-    ) -> MessagingReceipt {
-        sender.require_auth();
-        Self::__lz_send(env, dst_eid, message, options, sender, fee, refund_address)
-    }
-
-    pub fn pay_native_fee(env: &Env, fee_payer: &Address, native_fee: i128) {
-        fee_payer.require_auth();
-        Self::__pay_native(env, fee_payer, native_fee)
-    }
-
-    pub fn pay_zro_fee(env: &Env, fee_payer: &Address, zro_fee: i128) {
-        fee_payer.require_auth();
-        Self::__pay_zro(env, fee_payer, zro_fee)
-    }
-}
-
-const REMOTE_EID: u32 = 100;
-const UNSET_EID: u32 = 999;
-
-struct TestSetup<'a> {
-    env: Env,
-    #[allow(dead_code)]
-    token_admin: Address,
-    endpoint: Address,
-    #[allow(dead_code)]
-    owner: Address,
-    oapp_client: DummyOAppSenderClient<'a>,
-    native_token_client: TokenClient<'a>,
-    native_token_admin_client: StellarAssetClient<'a>,
-    zro_token_admin_client: StellarAssetClient<'a>,
-}
-
-fn setup<'a>() -> TestSetup<'a> {
-    let env = Env::default();
-
-    let owner = Address::generate(&env);
-
-    let token_admin = Address::generate(&env);
-    // Deploy mock tokens
-    let native_token_sac = env.register_stellar_asset_contract_v2(token_admin.clone());
-    let native_token = native_token_sac.address();
-    let native_token_client = TokenClient::new(&env, &native_token);
-    let native_token_admin_client = StellarAssetClient::new(&env, &native_token);
-
-    let zro_token_sac = env.register_stellar_asset_contract_v2(token_admin.clone());
-    let zro_token = zro_token_sac.address();
-    let zro_token_admin_client = StellarAssetClient::new(&env, &zro_token);
-
-    // Deploy mock endpoint
-    let endpoint = env.register(MockEndpoint, (&zro_token, &native_token));
-
-    // Deploy OApp
-    let oapp = env.register(DummyOAppSender, (&owner, &endpoint));
-    let oapp_client = DummyOAppSenderClient::new(&env, &oapp);
-
-    TestSetup {
-        env,
-        endpoint,
-        token_admin,
-        native_token_client,
-        native_token_admin_client,
-        zro_token_admin_client,
-        owner,
-        oapp_client,
-    }
-}
-
-#[test]
-fn test_quote_with_peer_set() {
-    let TestSetup { env, owner, oapp_client, .. } = setup();
-
-    // Set peer for destination
-    let peer = BytesN::from_array(&env, &[1; 32]);
-    let peer_option = Some(peer.clone());
-    env.mock_auths(&[MockAuth {
-        address: &owner,
-        invoke: &MockAuthInvoke {
-            contract: &oapp_client.address,
-            fn_name: "set_peer",
-            args: (&REMOTE_EID, &peer_option).into_val(&env),
-            sub_invokes: &[],
-        },
-    }]);
-    oapp_client.set_peer(&REMOTE_EID, &peer_option);
-
-    let message = Bytes::from_array(&env, &[1, 2, 3, 4, 5]);
-    let options = Bytes::from_array(&env, &[6, 7, 8]);
-
-    // Test quote without ZRO
-    let fee = oapp_client.quote(&REMOTE_EID, &message, &options, &false);
-    assert!(fee.native_fee > 0);
-    assert_eq!(fee.zro_fee, 0);
-
-    // Test quote with ZRO
-    let fee_with_zro = oapp_client.quote(&REMOTE_EID, &message, &options, &true);
-    assert!(fee_with_zro.native_fee > 0);
-    assert!(fee_with_zro.zro_fee > 0);
-}
-
-#[test]
-fn test_quote_without_peer_panics() {
-    let TestSetup { env, oapp_client, .. } = setup();
-
-    let message = Bytes::from_array(&env, &[1, 2, 3]);
-    let options = Bytes::from_array(&env, &[]);
-
-    // This should panic because no peer is set for UNSET_EID
-    let result = oapp_client.try_quote(&UNSET_EID, &message, &options, &false);
-    assert_eq!(result.err().unwrap().ok().unwrap(), OAppError::NoPeer.into());
-}
-
-#[test]
-fn test_lz_send_native_only() {
-    let TestSetup { env, oapp_client, endpoint, native_token_client, native_token_admin_client, .. } = setup();
-
-    env.mock_all_auths();
-
-    // Setup peer
-    let peer = BytesN::from_array(&env, &[2; 32]);
-    oapp_client.set_peer(&REMOTE_EID, &Some(peer));
-
-    // Setup sender with funds
-    let sender = Address::generate(&env);
-    let initial_balance = 10000i128;
-    native_token_admin_client.mint(&sender, &initial_balance);
-
-    let message = Bytes::from_array(&env, &[1, 2, 3]);
-    let options = Bytes::from_array(&env, &[]);
-    let refund_address = Address::generate(&env);
-
-    let fee = MessagingFee { native_fee: 1000, zro_fee: 0 };
-
-    // Send message (auth is mocked automatically)
-    let receipt = oapp_client.send(&sender, &REMOTE_EID, &message, &options, &fee, &refund_address);
-
-    // Verify receipt
-    assert_eq!(receipt.nonce, 1);
-    assert_eq!(receipt.fee.native_fee, fee.native_fee);
-
-    // Verify native token was transferred to endpoint
-    let sender_balance = native_token_client.balance(&sender);
-    assert_eq!(sender_balance, initial_balance - fee.native_fee);
-
-    let endpoint_balance = native_token_client.balance(&endpoint);
-    assert_eq!(endpoint_balance, fee.native_fee);
-}
-
-#[test]
-fn test_lz_send_with_zro() {
-    let TestSetup { env, oapp_client, native_token_admin_client, zro_token_admin_client, .. } = setup();
-
-    env.mock_all_auths();
-
-    // Setup peer
-    let peer = BytesN::from_array(&env, &[3; 32]);
-    oapp_client.set_peer(&REMOTE_EID, &Some(peer));
-
-    // Setup sender with both native and ZRO funds
-    let fee = MessagingFee { native_fee: 1000, zro_fee: 500 };
-
-    let sender = Address::generate(&env);
-    native_token_admin_client.mint(&sender, &fee.native_fee);
-    zro_token_admin_client.mint(&sender, &fee.zro_fee);
-
-    let message = Bytes::from_array(&env, &[1, 2, 3, 4]);
-    let options = Bytes::from_array(&env, &[5]);
-    let refund_address = Address::generate(&env);
-
-    // Send message with ZRO payment
-    let receipt = oapp_client.send(&sender, &REMOTE_EID, &message, &options, &fee, &refund_address);
-
-    assert_eq!(receipt.fee.zro_fee, fee.zro_fee);
-}
-
-#[test]
-fn test_pay_native() {
-    let TestSetup { env, oapp_client, endpoint, native_token_admin_client, .. } = setup();
-
-    env.mock_all_auths();
-
-    let payer = Address::generate(&env);
-    let payment_amount = 2000i128;
-
-    // Fund the payer
-    native_token_admin_client.mint(&payer, &payment_amount);
-
-    // Make payment
-    oapp_client.pay_native_fee(&payer, &payment_amount);
-
-    // Verify balances
-    assert_eq!(native_token_admin_client.balance(&payer), 0);
-    assert_eq!(native_token_admin_client.balance(&endpoint), payment_amount);
-}
-
-#[test]
-#[should_panic(expected = "balance is not sufficient to spend")]
-fn test_pay_native_insufficient_balance() {
-    let TestSetup { env, oapp_client, native_token_admin_client, .. } = setup();
-
-    env.mock_all_auths();
-
-    let balance = 500i128;
-    let payment_amount = 1000i128;
-
-    let payer = Address::generate(&env);
-
-    // Fund with less than required
-    native_token_admin_client.mint(&payer, &balance);
-
-    // This should panic due to insufficient balance
-    oapp_client.pay_native_fee(&payer, &payment_amount);
-}