@layerzerolabs/protocol-stellar-v2 0.2.8

package/contracts/endpoint-v2/src/tests/endpoint_v2/quote.rs

@@ -0,0 +1,144 @@
+use crate::{tests::endpoint_setup::setup, MessagingParams};
+use soroban_sdk::{
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    vec, Bytes, BytesN, IntoVal,
+};
+
+#[test]
+fn test_quote_with_native_fee() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let sender = soroban_sdk::Address::generate(env);
+    let dst_eid = 2u32;
+    let receiver = BytesN::from_array(env, &[1u8; 32]);
+    let message = Bytes::from_array(env, &[1, 2, 3, 4]);
+    let options = Bytes::new(env);
+    let fee_recipient = soroban_sdk::Address::generate(env);
+
+    // Setup mock send library with 100 native fee, 0 zro fee
+    let send_lib = context.setup_mock_send_lib(vec![env, dst_eid], 100, 0, fee_recipient);
+
+    // Register and set as default send library
+    context.mock_owner_auth("register_library", (&send_lib,));
+    endpoint_client.register_library(&send_lib);
+    context.mock_owner_auth("set_default_send_library", (&dst_eid, &send_lib));
+    endpoint_client.set_default_send_library(&dst_eid, &send_lib);
+
+    let params = MessagingParams { dst_eid, receiver, message, options, pay_in_zro: false };
+
+    // Mock auth for sender
+    env.mock_auths(&[MockAuth {
+        address: &sender,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "quote",
+            args: (&sender, &params).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    let fee = endpoint_client.quote(&sender, &params);
+    assert_eq!(fee.native_fee, 100);
+    assert_eq!(fee.zro_fee, 0);
+}
+
+#[test]
+fn test_quote_with_zro_fee() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let sender = soroban_sdk::Address::generate(env);
+    let dst_eid = 2u32;
+    let receiver = BytesN::from_array(env, &[1u8; 32]);
+    let message = Bytes::from_array(env, &[1, 2, 3, 4]);
+    let options = Bytes::new(env);
+    let fee_recipient = soroban_sdk::Address::generate(env);
+
+    // Setup ZRO token
+    context.mock_owner_auth("set_zro", (&context.zro_token_client.address,));
+    endpoint_client.set_zro(&context.zro_token_client.address);
+
+    // Setup mock send library with 50 native fee, 25 zro fee
+    let send_lib = context.setup_mock_send_lib(vec![env, dst_eid], 50, 25, fee_recipient);
+
+    // Register and set as default send library
+    context.mock_owner_auth("register_library", (&send_lib,));
+    endpoint_client.register_library(&send_lib);
+    context.mock_owner_auth("set_default_send_library", (&dst_eid, &send_lib));
+    endpoint_client.set_default_send_library(&dst_eid, &send_lib);
+
+    let params = MessagingParams { dst_eid, receiver, message, options, pay_in_zro: true };
+
+    // Mock auth for sender
+    env.mock_auths(&[MockAuth {
+        address: &sender,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "quote",
+            args: (&sender, &params).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    let fee = endpoint_client.quote(&sender, &params);
+    assert_eq!(fee.native_fee, 50);
+    assert_eq!(fee.zro_fee, 25);
+}
+
+#[test]
+fn test_quote_with_custom_send_library() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let sender = soroban_sdk::Address::generate(env);
+    let dst_eid = 2u32;
+    let receiver = BytesN::from_array(env, &[1u8; 32]);
+    let message = Bytes::from_array(env, &[1, 2, 3, 4]);
+    let options = Bytes::new(env);
+    let fee_recipient = soroban_sdk::Address::generate(env);
+
+    // Setup default send library with 100 fee
+    let default_lib = context.setup_mock_send_lib(vec![env, dst_eid], 100, 0, fee_recipient.clone());
+    context.mock_owner_auth("register_library", (&default_lib,));
+    endpoint_client.register_library(&default_lib);
+    context.mock_owner_auth("set_default_send_library", (&dst_eid, &default_lib));
+    endpoint_client.set_default_send_library(&dst_eid, &default_lib);
+
+    // Setup custom send library with 200 fee
+    let custom_lib = context.setup_mock_send_lib(vec![env, dst_eid], 200, 0, fee_recipient);
+    context.mock_owner_auth("register_library", (&custom_lib,));
+    endpoint_client.register_library(&custom_lib);
+
+    // Set custom library for sender
+    env.mock_auths(&[MockAuth {
+        address: &sender,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "set_send_library",
+            args: (&sender, &sender, &dst_eid, &custom_lib).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.set_send_library(&sender, &sender, &dst_eid, &Some(custom_lib));
+
+    let params = MessagingParams { dst_eid, receiver, message, options, pay_in_zro: false };
+
+    // Mock auth for sender
+    env.mock_auths(&[MockAuth {
+        address: &sender,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "quote",
+            args: (&sender, &params).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    let fee = endpoint_client.quote(&sender, &params);
+    // Should use custom library with 200 fee
+    assert_eq!(fee.native_fee, 200);
+}

package/contracts/endpoint-v2/src/tests/endpoint_v2/recover_token.rs

@@ -0,0 +1,72 @@
+use crate::tests::endpoint_setup::setup;
+use soroban_sdk::{
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    Address, IntoVal,
+};
+
+#[test]
+fn test_recover_token() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+    let recipient = Address::generate(env);
+
+    let amount = 1000i128;
+
+    // Mint tokens to the endpoint contract
+    context.mint_native(&context.contract_id, amount);
+
+    // Verify initial balances
+    assert_eq!(context.native_token_client.balance(&context.contract_id), amount);
+    assert_eq!(context.native_token_client.balance(&recipient), 0);
+
+    // Recover tokens with owner auth
+    let token_address = context.native_token_client.address.clone();
+    env.mock_auths(&[MockAuth {
+        address: &context.owner,
+        invoke: &MockAuthInvoke {
+            contract: &context.contract_id,
+            fn_name: "recover_token",
+            args: (&token_address, &recipient, amount).into_val(env),
+            sub_invokes: &[MockAuthInvoke {
+                contract: &token_address,
+                fn_name: "transfer",
+                args: (&context.contract_id, &recipient, amount).into_val(env),
+                sub_invokes: &[],
+            }],
+        },
+    }]);
+    endpoint_client.recover_token(&token_address, &recipient, &amount);
+
+    // Verify tokens were transferred
+    assert_eq!(context.native_token_client.balance(&context.contract_id), 0);
+    assert_eq!(context.native_token_client.balance(&recipient), amount);
+}
+
+#[test]
+#[should_panic(expected = "Error(Auth, InvalidAction)")]
+fn test_recover_token_fails_for_non_owner() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+    let non_owner = Address::generate(env);
+    let recipient = Address::generate(env);
+
+    let amount = 1000i128;
+
+    // Mint tokens to the endpoint contract
+    context.mint_native(&context.contract_id, amount);
+
+    // Try to recover tokens with non-owner auth (should fail)
+    let token_address = context.native_token_client.address.clone();
+    env.mock_auths(&[MockAuth {
+        address: &non_owner,
+        invoke: &MockAuthInvoke {
+            contract: &context.contract_id,
+            fn_name: "recover_token",
+            args: (&token_address, &recipient, amount).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.recover_token(&token_address, &recipient, &amount);
+}

package/contracts/endpoint-v2/src/tests/endpoint_v2/require_oapp_auth.rs

@@ -0,0 +1,29 @@
+use crate::{storage, tests::endpoint_setup::setup};
+use soroban_sdk::testutils::{Address as _, MockAuth, MockAuthInvoke};
+use soroban_sdk::IntoVal;
+
+#[test]
+fn test_require_oapp_auth_delegate_set() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+    let oapp = soroban_sdk::Address::generate(env);
+    let delegate = soroban_sdk::Address::generate(env);
+
+    // Set delegate
+    let delegate_option = Some(delegate.clone());
+    env.mock_auths(&[MockAuth {
+        address: &oapp,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "set_delegate",
+            args: (&oapp, &delegate_option).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.set_delegate(&oapp, &delegate_option);
+
+    // Verify delegate was set
+    let stored_delegate = env.as_contract(&endpoint_client.address, || storage::EndpointStorage::delegate(env, &oapp));
+    assert_eq!(stored_delegate, Some(delegate));
+}