@layerzerolabs/protocol-stellar-v2 0.2.18 → 0.2.20

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

@@ -14,7 +14,8 @@ 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);
+        // Store as Option<Address> so zro() can return None when unavailable.
+        env.storage().instance().set(&symbol_short!("zro"), &Some(zro_token.clone()));
         env.storage().instance().set(&symbol_short!("ntk"), native_token);
     }
 
@@ -27,6 +28,11 @@ impl MockEndpoint {
     }
 
     pub fn send(env: Env, _sender: Address, params: MessagingParams, _refund_address: Address) -> MessagingReceipt {
+        // Record last send call for assertions
+        env.storage().instance().set(&symbol_short!("snds"), &_sender);
+        env.storage().instance().set(&symbol_short!("sndp"), &params);
+        env.storage().instance().set(&symbol_short!("sndr"), &_refund_address);
+
         // Return mock receipt
         MessagingReceipt {
             guid: BytesN::from_array(&env, &[1u8; 32]),
@@ -35,14 +41,26 @@ impl MockEndpoint {
         }
     }
 
+    pub fn last_send(env: Env) -> (Address, MessagingParams, Address) {
+        (
+            env.storage().instance().get(&symbol_short!("snds")).unwrap(),
+            env.storage().instance().get(&symbol_short!("sndp")).unwrap(),
+            env.storage().instance().get(&symbol_short!("sndr")).unwrap(),
+        )
+    }
+
     pub fn zro(env: Env) -> Option<Address> {
-        // Return a mock ZRO token address
-        env.storage().instance().get(&symbol_short!("zro")).unwrap()
+        // Return a mock ZRO token address (or None if not set)
+        env.storage().instance().get(&symbol_short!("zro")).unwrap_or(None)
     }
 
     pub fn native_token(env: Env) -> Address {
         env.storage().instance().get(&symbol_short!("ntk")).unwrap()
     }
+
+    pub fn set_zro(env: Env, zro: &Option<Address>) {
+        env.storage().instance().set(&symbol_short!("zro"), zro);
+    }
 }
 
 #[oapp_macros::oapp]
@@ -101,12 +119,12 @@ 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: Address,
+    zro_token: Address,
     native_token_client: TokenClient<'a>,
     native_token_admin_client: StellarAssetClient<'a>,
     zro_token_admin_client: StellarAssetClient<'a>,
@@ -142,41 +160,124 @@ fn setup<'a>() -> TestSetup<'a> {
         native_token_client,
         native_token_admin_client,
         zro_token_admin_client,
+        native_token,
+        zro_token,
         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]);
+fn set_peer_with_auth(
+    env: &Env,
+    owner: &Address,
+    oapp_client: &DummyOAppSenderClient<'_>,
+    eid: u32,
+    peer: &BytesN<32>,
+) {
     let peer_option = Some(peer.clone());
     env.mock_auths(&[MockAuth {
-        address: &owner,
+        address: owner,
         invoke: &MockAuthInvoke {
             contract: &oapp_client.address,
             fn_name: "set_peer",
-            args: (&REMOTE_EID, &peer_option).into_val(&env),
+            args: (&eid, &peer_option).into_val(env),
             sub_invokes: &[],
         },
     }]);
-    oapp_client.set_peer(&REMOTE_EID, &peer_option);
+    oapp_client.set_peer(&eid, &peer_option);
+}
+
+fn mint_to(
+    env: &Env,
+    token_admin: &Address,
+    token: &Address,
+    token_admin_client: &StellarAssetClient<'_>,
+    to: &Address,
+    amount: i128,
+) {
+    env.mock_auths(&[MockAuth {
+        address: token_admin,
+        invoke: &MockAuthInvoke {
+            contract: token,
+            fn_name: "mint",
+            args: (to, amount).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    token_admin_client.mint(to, &amount);
+}
+
+fn mock_send_auth(
+    env: &Env,
+    sender: &Address,
+    oapp_client: &DummyOAppSenderClient<'_>,
+    dst_eid: u32,
+    message: &Bytes,
+    options: &Bytes,
+    fee: &MessagingFee,
+    refund_address: &Address,
+    native_token: &Address,
+    endpoint: &Address,
+    zro_token: &Address,
+) {
+    let native_transfer = MockAuthInvoke {
+        contract: native_token,
+        fn_name: "transfer",
+        args: (sender, endpoint, &fee.native_fee).into_val(env),
+        sub_invokes: &[],
+    };
+
+    if fee.zro_fee > 0 {
+        let zro_transfer = MockAuthInvoke {
+            contract: zro_token,
+            fn_name: "transfer",
+            args: (sender, endpoint, &fee.zro_fee).into_val(env),
+            sub_invokes: &[],
+        };
+        let sub_invokes = [native_transfer, zro_transfer];
+        env.mock_auths(&[MockAuth {
+            address: sender,
+            invoke: &MockAuthInvoke {
+                contract: &oapp_client.address,
+                fn_name: "send",
+                args: (sender, &dst_eid, message, options, fee, refund_address).into_val(env),
+                sub_invokes: &sub_invokes,
+            },
+        }]);
+    } else {
+        let sub_invokes = [native_transfer];
+        env.mock_auths(&[MockAuth {
+            address: sender,
+            invoke: &MockAuthInvoke {
+                contract: &oapp_client.address,
+                fn_name: "send",
+                args: (sender, &dst_eid, message, options, fee, refund_address).into_val(env),
+                sub_invokes: &sub_invokes,
+            },
+        }]);
+    }
+}
+
+#[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]);
+    set_peer_with_auth(&env, &owner, &oapp_client, REMOTE_EID, &peer);
 
     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.native_fee, 1000);
     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);
+    assert_eq!(fee_with_zro.native_fee, 1000);
+    assert_eq!(fee_with_zro.zro_fee, 500);
 }
 
 #[test]
@@ -193,80 +294,158 @@ fn test_quote_without_peer_panics() {
 
 #[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();
+    let TestSetup {
+        env,
+        oapp_client,
+        endpoint,
+        native_token,
+        zro_token,
+        native_token_client,
+        native_token_admin_client,
+        token_admin,
+        owner,
+        ..
+    } = setup();
 
     // Setup peer
     let peer = BytesN::from_array(&env, &[2; 32]);
-    oapp_client.set_peer(&REMOTE_EID, &Some(peer));
+    set_peer_with_auth(&env, &owner, &oapp_client, REMOTE_EID, &peer);
 
-    // Setup sender with funds
     let sender = Address::generate(&env);
-    let initial_balance = 10000i128;
-    native_token_admin_client.mint(&sender, &initial_balance);
+    mint_to(&env, &token_admin, &native_token, &native_token_admin_client, &sender, 1000i128);
 
     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)
+    mock_send_auth(
+        &env,
+        &sender,
+        &oapp_client,
+        REMOTE_EID,
+        &message,
+        &options,
+        &fee,
+        &refund_address,
+        &native_token,
+        &endpoint,
+        &zro_token,
+    );
     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);
+    assert_eq!(receipt.fee.native_fee, 1000);
+    assert_eq!(receipt.fee.zro_fee, 0);
+
+    // Assert the endpoint received the correct send params
+    let endpoint_client = MockEndpointClient::new(&env, &endpoint);
+    let (endpoint_sender, params, refund) = endpoint_client.last_send();
+    assert_eq!(endpoint_sender, oapp_client.address);
+    assert_eq!(params.dst_eid, REMOTE_EID);
+    assert_eq!(params.receiver, peer);
+    assert_eq!(params.message, message);
+    assert_eq!(params.options, options);
+    assert_eq!(params.pay_in_zro, false);
+    assert_eq!(refund, refund_address);
+
+    assert_eq!(native_token_client.balance(&sender), 0);
+    assert_eq!(native_token_client.balance(&endpoint), 1000);
+    assert_eq!(TokenClient::new(&env, &zro_token).balance(&endpoint), 0);
 }
 
 #[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();
+    let TestSetup {
+        env,
+        oapp_client,
+        endpoint,
+        native_token,
+        zro_token,
+        native_token_client,
+        native_token_admin_client,
+        zro_token_admin_client,
+        token_admin,
+        owner,
+        ..
+    } = setup();
 
     // 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 };
+    set_peer_with_auth(&env, &owner, &oapp_client, REMOTE_EID, &peer);
 
     let sender = Address::generate(&env);
-    native_token_admin_client.mint(&sender, &fee.native_fee);
-    zro_token_admin_client.mint(&sender, &fee.zro_fee);
+    let fee = MessagingFee { native_fee: 1000, zro_fee: 500 };
+    mint_to(&env, &token_admin, &native_token, &native_token_admin_client, &sender, fee.native_fee);
+    mint_to(&env, &token_admin, &zro_token, &zro_token_admin_client, &sender, fee.zro_fee);
 
-    let message = Bytes::from_array(&env, &[1, 2, 3, 4]);
-    let options = Bytes::from_array(&env, &[5]);
+    let message = Bytes::from_array(&env, &[4, 5, 6]);
+    let options = Bytes::from_array(&env, &[7]);
     let refund_address = Address::generate(&env);
 
-    // Send message with ZRO payment
+    mock_send_auth(
+        &env,
+        &sender,
+        &oapp_client,
+        REMOTE_EID,
+        &message,
+        &options,
+        &fee,
+        &refund_address,
+        &native_token,
+        &endpoint,
+        &zro_token,
+    );
     let receipt = oapp_client.send(&sender, &REMOTE_EID, &message, &options, &fee, &refund_address);
 
-    assert_eq!(receipt.fee.zro_fee, fee.zro_fee);
+    assert_eq!(receipt.nonce, 1);
+    assert_eq!(receipt.fee.native_fee, 1000);
+    assert_eq!(receipt.fee.zro_fee, 500);
+
+    // Assert the endpoint received the correct send params
+    let endpoint_client = MockEndpointClient::new(&env, &endpoint);
+    let (endpoint_sender, params, refund) = endpoint_client.last_send();
+    assert_eq!(endpoint_sender, oapp_client.address);
+    assert_eq!(params.dst_eid, REMOTE_EID);
+    assert_eq!(params.receiver, peer);
+    assert_eq!(params.message, message);
+    assert_eq!(params.options, options);
+    assert_eq!(params.pay_in_zro, true);
+    assert_eq!(refund, refund_address);
+
+    assert_eq!(native_token_client.balance(&sender), 0);
+    assert_eq!(native_token_client.balance(&endpoint), 1000);
+
+    let zro_token_client = TokenClient::new(&env, &zro_token);
+    assert_eq!(zro_token_client.balance(&sender), 0);
+    assert_eq!(zro_token_client.balance(&endpoint), 500);
 }
 
 #[test]
 fn test_pay_native() {
-    let TestSetup { env, oapp_client, endpoint, native_token_admin_client, .. } = setup();
-
-    env.mock_all_auths();
+    let TestSetup { env, oapp_client, endpoint, native_token, native_token_admin_client, token_admin, .. } = setup();
 
     let payer = Address::generate(&env);
     let payment_amount = 2000i128;
 
     // Fund the payer
-    native_token_admin_client.mint(&payer, &payment_amount);
+    mint_to(&env, &token_admin, &native_token, &native_token_admin_client, &payer, payment_amount);
 
     // Make payment
+    env.mock_auths(&[MockAuth {
+        address: &payer,
+        invoke: &MockAuthInvoke {
+            contract: &oapp_client.address,
+            fn_name: "pay_native_fee",
+            args: (&payer, &payment_amount).into_val(&env),
+            sub_invokes: &[MockAuthInvoke {
+                contract: &native_token,
+                fn_name: "transfer",
+                args: (&payer, &endpoint, &payment_amount).into_val(&env),
+                sub_invokes: &[],
+            }],
+        },
+    }]);
     oapp_client.pay_native_fee(&payer, &payment_amount);
 
     // Verify balances
@@ -277,9 +456,7 @@ fn test_pay_native() {
 #[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 TestSetup { env, oapp_client, endpoint, native_token, native_token_admin_client, token_admin, .. } = setup();
 
     let balance = 500i128;
     let payment_amount = 1000i128;
@@ -287,8 +464,106 @@ fn test_pay_native_insufficient_balance() {
     let payer = Address::generate(&env);
 
     // Fund with less than required
-    native_token_admin_client.mint(&payer, &balance);
+    mint_to(&env, &token_admin, &native_token, &native_token_admin_client, &payer, balance);
 
     // This should panic due to insufficient balance
+    env.mock_auths(&[MockAuth {
+        address: &payer,
+        invoke: &MockAuthInvoke {
+            contract: &oapp_client.address,
+            fn_name: "pay_native_fee",
+            args: (&payer, &payment_amount).into_val(&env),
+            sub_invokes: &[MockAuthInvoke {
+                contract: &native_token,
+                fn_name: "transfer",
+                args: (&payer, &endpoint, &payment_amount).into_val(&env),
+                sub_invokes: &[],
+            }],
+        },
+    }]);
     oapp_client.pay_native_fee(&payer, &payment_amount);
 }
+
+#[test]
+fn test_pay_zro_success() {
+    let TestSetup { env, oapp_client, endpoint, zro_token, zro_token_admin_client, token_admin, .. } = setup();
+
+    let payer = Address::generate(&env);
+    let payment_amount = 500i128;
+    mint_to(&env, &token_admin, &zro_token, &zro_token_admin_client, &payer, payment_amount);
+
+    env.mock_auths(&[MockAuth {
+        address: &payer,
+        invoke: &MockAuthInvoke {
+            contract: &oapp_client.address,
+            fn_name: "pay_zro_fee",
+            args: (&payer, &payment_amount).into_val(&env),
+            sub_invokes: &[MockAuthInvoke {
+                contract: &zro_token,
+                fn_name: "transfer",
+                args: (&payer, &endpoint, &payment_amount).into_val(&env),
+                sub_invokes: &[],
+            }],
+        },
+    }]);
+    oapp_client.pay_zro_fee(&payer, &payment_amount);
+
+    assert_eq!(zro_token_admin_client.balance(&payer), 0);
+    assert_eq!(zro_token_admin_client.balance(&endpoint), payment_amount);
+}
+
+#[test]
+#[should_panic(expected = "balance is not sufficient to spend")]
+fn test_pay_zro_insufficient_balance() {
+    let TestSetup { env, oapp_client, endpoint, zro_token, zro_token_admin_client, token_admin, .. } = setup();
+
+    let payer = Address::generate(&env);
+    let balance = 100i128;
+    let payment_amount = 500i128;
+
+    // Fund with less than required
+    mint_to(&env, &token_admin, &zro_token, &zro_token_admin_client, &payer, balance);
+
+    env.mock_auths(&[MockAuth {
+        address: &payer,
+        invoke: &MockAuthInvoke {
+            contract: &oapp_client.address,
+            fn_name: "pay_zro_fee",
+            args: (&payer, &payment_amount).into_val(&env),
+            sub_invokes: &[MockAuthInvoke {
+                contract: &zro_token,
+                fn_name: "transfer",
+                args: (&payer, &endpoint, &payment_amount).into_val(&env),
+                sub_invokes: &[],
+            }],
+        },
+    }]);
+    oapp_client.pay_zro_fee(&payer, &payment_amount);
+}
+
+#[test]
+fn test_pay_zro_unavailable_returns_error() {
+    let TestSetup { env, oapp_client, endpoint, zro_token, .. } = setup();
+
+    let endpoint_client = MockEndpointClient::new(&env, &endpoint);
+    endpoint_client.set_zro(&None);
+
+    let payer = Address::generate(&env);
+    let payment_amount = 500i128;
+
+    env.mock_auths(&[MockAuth {
+        address: &payer,
+        invoke: &MockAuthInvoke {
+            contract: &oapp_client.address,
+            fn_name: "pay_zro_fee",
+            args: (&payer, &payment_amount).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    let result = oapp_client.try_pay_zro_fee(&payer, &payment_amount);
+    assert_eq!(result.err().unwrap().ok().unwrap(), OAppError::ZroTokenUnavailable.into());
+
+    // Ensure we did not transfer any ZRO accidentally
+    let token_client = TokenClient::new(&env, &zro_token);
+    assert_eq!(token_client.balance(&payer), 0);
+}

package/contracts/oapps/oft/Cargo.toml

@@ -5,15 +5,22 @@ edition.workspace = true
 license.workspace = true
 
 [lib]
-crate-type = ["rlib"]
+crate-type = ["cdylib", "rlib"]
 doctest = false
 
+[features]
+library = []
+testutils = []
+
 [dependencies]
 soroban-sdk = { workspace = true }
-endpoint-v2 = { workspace = true, features = ["library"] }
+cfg-if = { workspace = true }
 utils = { workspace = true }
-oapp = { workspace = true }
 common-macros = { workspace = true }
+endpoint-v2 = { workspace = true, features = ["library"] }
+oapp = { workspace = true }
+oapp-macros = { workspace = true }
+oft-core = { workspace = true }
 
 [dev-dependencies]
 soroban-sdk = { workspace = true, features = ["testutils"] }
@@ -21,7 +28,3 @@ simple-message-lib = { workspace = true }
 message-lib-common = { workspace = true, features = ["testutils"] }
 endpoint-v2 = { workspace = true, features = ["testutils"] }
 utils = { workspace = true, features = ["testutils"] }
-insta = { workspace = true }
-oapp-macros = { workspace = true }
-stellar-macros = { workspace = true }
-stellar-tokens = { workspace = true }

package/contracts/oapps/{oft-std → oft}/integration-tests/extensions/test_oft_fee.rs

@@ -8,10 +8,9 @@
 use crate::integration_tests::{
     setup::{create_recipient_address, decode_packet, setup, wire_endpoint, wire_oft, TestSetup},
     utils::{
-        address_to_peer_bytes32, create_send_param, lz_receive, mint_to,
-        quote_oft, quote_send, scan_packet_sent_event, send, send_with_fee,
-        set_default_fee_bps, set_fee_bps, set_fee_deposit_address, token_balance,
-        transfer_sac_admin, validate_packet,
+        address_to_peer_bytes32, create_send_param, lz_receive, mint_to, quote_oft, quote_send,
+        scan_packet_sent_event, send, send_with_fee, set_default_fee_bps, set_fee_bps, set_fee_deposit_address,
+        token_balance, transfer_sac_admin, validate_packet,
     },
 };
 use soroban_sdk::{testutils::Address as _, token::TokenClient, Address};

package/contracts/oapps/{oft-std → oft}/integration-tests/extensions/test_pausable.rs

@@ -6,9 +6,8 @@
 use crate::integration_tests::{
     setup::{create_recipient_address, decode_packet, setup, wire_endpoint, wire_oft, TestSetup},
     utils::{
-        address_to_peer_bytes32, create_send_param, is_paused, lz_receive, mint_to,
-        quote_oft, quote_send, scan_packet_sent_event, send, set_paused, transfer_sac_admin,
-        try_lz_receive, try_send, validate_packet,
+        address_to_peer_bytes32, create_send_param, is_paused, lz_receive, mint_to, quote_oft, quote_send,
+        scan_packet_sent_event, send, set_paused, transfer_sac_admin, try_lz_receive, try_send, validate_packet,
     },
 };
 use soroban_sdk::{testutils::Address as _, token::TokenClient, Address};

package/contracts/oapps/{oft-std → oft}/integration-tests/extensions/test_rate_limiter.rs

@@ -3,6 +3,7 @@
 //! Tests verify that the RateLimiter extension properly enforces rate limits
 //! on cross-chain transfers. Uses real EndpointV2 and SimpleMessageLib.
 
+use crate::extensions::rate_limiter::Direction;
 use crate::integration_tests::{
     setup::{create_recipient_address, decode_packet, setup, wire_endpoint, wire_oft, TestSetup},
     utils::{
@@ -11,7 +12,6 @@ use crate::integration_tests::{
         try_send, validate_packet,
     },
 };
-use oft::extensions::rate_limiter::Direction;
 use soroban_sdk::{testutils::Address as _, token::TokenClient, Address};
 
 /// Test e2e send without rate limit (default - unlimited)

package/contracts/oapps/oft/integration-tests/mod.rs

@@ -1,3 +1,3 @@
+pub mod extensions;
 pub mod setup;
-pub mod test_with_sml;
 pub mod utils;