@layerzerolabs/protocol-stellar-v2 0.2.8

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

@@ -0,0 +1,211 @@
+use crate::{events::LzReceiveAlert, tests::endpoint_setup::setup, Origin};
+use soroban_sdk::{
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    Bytes, BytesN, IntoVal,
+};
+use utils::testing_utils::assert_event;
+
+#[test]
+fn test_lz_receive_alert_auth() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let executor = soroban_sdk::Address::generate(env);
+    let receiver = soroban_sdk::Address::generate(env);
+    let src_eid = 2u32;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+    let nonce = 1u64;
+    let guid = BytesN::from_array(env, &[5u8; 32]);
+    let gas = 1000i128;
+    let value = 100i128;
+    let message = Bytes::from_array(env, &[1, 2, 3, 4]);
+    let extra_data = Bytes::from_array(env, &[5, 6]);
+    let reason = Bytes::from_array(env, &[7, 8, 9]);
+
+    let origin = Origin { src_eid, sender, nonce };
+
+    // Mock auth for executor - test that the function requires auth from executor
+    env.mock_auths(&[MockAuth {
+        address: &executor,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "lz_receive_alert",
+            args: (&executor, &origin, &receiver, &guid, &gas, &value, &message, &extra_data, &reason).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    // This should not panic if auth is correct
+    endpoint_client.lz_receive_alert(
+        &executor,
+        &origin,
+        &receiver,
+        &guid,
+        &gas,
+        &value,
+        &message,
+        &extra_data,
+        &reason,
+    );
+
+    // Verify LzReceiveAlert event was published
+    assert_event(
+        env,
+        &endpoint_client.address,
+        LzReceiveAlert {
+            receiver: receiver.clone(),
+            executor: executor.clone(),
+            origin: origin.clone(),
+            guid: guid.clone(),
+            gas,
+            value,
+            message: message.clone(),
+            extra_data: extra_data.clone(),
+            reason: reason.clone(),
+        },
+    );
+}
+
+#[test]
+fn test_lz_receive_alert_with_empty_data() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let executor = soroban_sdk::Address::generate(env);
+    let receiver = soroban_sdk::Address::generate(env);
+    let src_eid = 2u32;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+    let nonce = 1u64;
+    let guid = BytesN::from_array(env, &[5u8; 32]);
+    let gas = 0i128;
+    let value = 0i128;
+    let message = Bytes::new(env);
+    let extra_data = Bytes::new(env);
+    let reason = Bytes::new(env);
+
+    let origin = Origin { src_eid, sender, nonce };
+
+    // Mock auth for executor
+    env.mock_auths(&[MockAuth {
+        address: &executor,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "lz_receive_alert",
+            args: (&executor, &origin, &receiver, &guid, &gas, &value, &message, &extra_data, &reason).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    // This should not panic
+    endpoint_client.lz_receive_alert(
+        &executor,
+        &origin,
+        &receiver,
+        &guid,
+        &gas,
+        &value,
+        &message,
+        &extra_data,
+        &reason,
+    );
+
+    // Verify LzReceiveAlert event was published with empty data
+    assert_event(
+        env,
+        &endpoint_client.address,
+        LzReceiveAlert {
+            receiver: receiver.clone(),
+            executor: executor.clone(),
+            origin: origin.clone(),
+            guid: guid.clone(),
+            gas,
+            value,
+            message: message.clone(),
+            extra_data: extra_data.clone(),
+            reason: reason.clone(),
+        },
+    );
+}
+
+#[test]
+fn test_lz_receive_alert_with_different_origins() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+
+    let executor = soroban_sdk::Address::generate(env);
+    let receiver = soroban_sdk::Address::generate(env);
+    let src_eid = 2u32;
+    let sender = BytesN::from_array(env, &[1u8; 32]);
+    let guid = BytesN::from_array(env, &[5u8; 32]);
+    let gas = 1000i128;
+    let value = 100i128;
+    let message = Bytes::from_array(env, &[1, 2, 3, 4]);
+    let extra_data = Bytes::from_array(env, &[5, 6]);
+    let reason = Bytes::from_array(env, &[7, 8, 9]);
+
+    // Call with nonce 1
+    let origin1 = Origin { src_eid, sender: sender.clone(), nonce: 1 };
+    env.mock_auths(&[MockAuth {
+        address: &executor,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "lz_receive_alert",
+            args: (&executor, &origin1, &receiver, &guid, &gas, &value, &message, &extra_data, &reason).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.lz_receive_alert(
+        &executor,
+        &origin1,
+        &receiver,
+        &guid,
+        &gas,
+        &value,
+        &message,
+        &extra_data,
+        &reason,
+    );
+
+    // Call with nonce 2 should also succeed
+    let origin2 = Origin { src_eid, sender, nonce: 2 };
+    env.mock_auths(&[MockAuth {
+        address: &executor,
+        invoke: &MockAuthInvoke {
+            contract: &endpoint_client.address,
+            fn_name: "lz_receive_alert",
+            args: (&executor, &origin2, &receiver, &guid, &gas, &value, &message, &extra_data, &reason).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_client.lz_receive_alert(
+        &executor,
+        &origin2,
+        &receiver,
+        &guid,
+        &gas,
+        &value,
+        &message,
+        &extra_data,
+        &reason,
+    );
+
+    // Verify LzReceiveAlert events were published for both calls
+    assert_event(
+        env,
+        &endpoint_client.address,
+        LzReceiveAlert {
+            receiver: receiver.clone(),
+            executor: executor.clone(),
+            origin: origin2.clone(),
+            guid: guid.clone(),
+            gas,
+            value,
+            message: message.clone(),
+            extra_data: extra_data.clone(),
+            reason: reason.clone(),
+        },
+    );
+}

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

@@ -0,0 +1,18 @@
+mod clear;
+mod delegate;
+mod initializable;
+mod lz_receive_alert;
+mod native_token;
+mod owner;
+mod pay_messaging_fees;
+mod quote;
+mod recover_token;
+mod require_oapp_auth;
+mod send;
+mod set_delegate;
+mod set_zro;
+mod transfer_ownership;
+mod ttl_config;
+mod verifiable;
+mod verify;
+mod zro;

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

@@ -0,0 +1,10 @@
+use crate::tests::endpoint_setup::setup;
+
+#[test]
+fn test_native_token() {
+    let context = setup();
+    let endpoint_client = &context.endpoint_client;
+
+    let native_token = endpoint_client.native_token();
+    assert_eq!(native_token, context.native_token_client.address);
+}

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

@@ -0,0 +1,10 @@
+use crate::tests::endpoint_setup::setup;
+
+#[test]
+fn test_owner() {
+    let context = setup();
+    let endpoint_client = &context.endpoint_client;
+
+    let owner = endpoint_client.owner();
+    assert_eq!(owner, Some(context.owner));
+}

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

@@ -0,0 +1,424 @@
+use crate::{tests::endpoint_setup::setup, EndpointV2, FeeRecipient, FeesAndPacket};
+use soroban_sdk::{testutils::Address as _, Address, Bytes, Vec};
+
+#[test]
+fn test_pay_native_fees_exact_amount() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+    let recipient = Address::generate(env);
+    let refund_address = Address::generate(env);
+
+    // Setup: Mint native tokens to endpoint
+    context.mint_native(&endpoint_client.address, 100);
+
+    let mut native_fee_recipients = Vec::new(env);
+    native_fee_recipients.push_back(FeeRecipient { address: recipient.clone(), amount: 100 });
+    let send_result =
+        FeesAndPacket { native_fee_recipients, zro_fee_recipients: Vec::new(env), encoded_packet: Bytes::new(env) };
+
+    let fee = env.as_contract(&endpoint_client.address, || {
+        EndpointV2::pay_messaging_fees(
+            env,
+            false,
+            &send_result.native_fee_recipients,
+            &send_result.zro_fee_recipients,
+            &refund_address,
+        )
+    });
+
+    // Verify fee was calculated correctly
+    assert_eq!(fee.native_fee, 100);
+    assert_eq!(fee.zro_fee, 0);
+
+    // Verify recipient received payment
+    assert_eq!(context.native_token_client.balance(&recipient), 100);
+
+    // Verify no refund
+    assert_eq!(context.native_token_client.balance(&refund_address), 0);
+}
+
+#[test]
+fn test_pay_native_fees_with_refund() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+    let recipient = Address::generate(env);
+    let refund_address = Address::generate(env);
+
+    // Setup: Mint more native tokens than needed
+    context.mint_native(&endpoint_client.address, 200);
+
+    let mut native_fee_recipients = Vec::new(env);
+    native_fee_recipients.push_back(FeeRecipient { address: recipient.clone(), amount: 100 });
+    let send_result =
+        FeesAndPacket { native_fee_recipients, zro_fee_recipients: Vec::new(env), encoded_packet: Bytes::new(env) };
+
+    let fee = env.as_contract(&endpoint_client.address, || {
+        EndpointV2::pay_messaging_fees(
+            env,
+            false,
+            &send_result.native_fee_recipients,
+            &send_result.zro_fee_recipients,
+            &refund_address,
+        )
+    });
+
+    // Verify fee was calculated correctly
+    assert_eq!(fee.native_fee, 100);
+    assert_eq!(fee.zro_fee, 0);
+
+    // Verify recipient received payment
+    assert_eq!(context.native_token_client.balance(&recipient), 100);
+
+    // Verify refund (200 - 100 = 100)
+    assert_eq!(context.native_token_client.balance(&refund_address), 100);
+}
+
+#[test]
+fn test_pay_zro_fees_exact_amount() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+    let recipient = Address::generate(env);
+    let refund_address = Address::generate(env);
+
+    // Setup: Set ZRO token
+    context.mock_owner_auth("set_zro", (&context.zro_token_client.address,));
+    endpoint_client.set_zro(&context.zro_token_client.address);
+
+    // Mint ZRO tokens to endpoint
+    context.mint_zro(&endpoint_client.address, 50);
+
+    let mut zro_fee_recipients = Vec::new(env);
+    zro_fee_recipients.push_back(FeeRecipient { address: recipient.clone(), amount: 50 });
+    let send_result =
+        FeesAndPacket { native_fee_recipients: Vec::new(env), zro_fee_recipients, encoded_packet: Bytes::new(env) };
+
+    let fee = env.as_contract(&endpoint_client.address, || {
+        EndpointV2::pay_messaging_fees(
+            env,
+            true,
+            &send_result.native_fee_recipients,
+            &send_result.zro_fee_recipients,
+            &refund_address,
+        )
+    });
+
+    // Verify fee was calculated correctly
+    assert_eq!(fee.native_fee, 0);
+    assert_eq!(fee.zro_fee, 50);
+
+    // Verify recipient received payment
+    assert_eq!(context.zro_token_client.balance(&recipient), 50);
+
+    // Verify no refund
+    assert_eq!(context.zro_token_client.balance(&refund_address), 0);
+}
+
+#[test]
+fn test_pay_zro_fees_with_refund() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+    let recipient = Address::generate(env);
+    let refund_address = Address::generate(env);
+
+    // Setup: Set ZRO token
+    context.mock_owner_auth("set_zro", (&context.zro_token_client.address,));
+    endpoint_client.set_zro(&context.zro_token_client.address);
+
+    // Mint more ZRO tokens than needed
+    context.mint_zro(&endpoint_client.address, 100);
+
+    let mut zro_fee_recipients = Vec::new(env);
+    zro_fee_recipients.push_back(FeeRecipient { address: recipient.clone(), amount: 50 });
+    let send_result =
+        FeesAndPacket { native_fee_recipients: Vec::new(env), zro_fee_recipients, encoded_packet: Bytes::new(env) };
+
+    let fee = env.as_contract(&endpoint_client.address, || {
+        EndpointV2::pay_messaging_fees(
+            env,
+            true,
+            &send_result.native_fee_recipients,
+            &send_result.zro_fee_recipients,
+            &refund_address,
+        )
+    });
+
+    // Verify fee was calculated correctly
+    assert_eq!(fee.native_fee, 0);
+    assert_eq!(fee.zro_fee, 50);
+
+    // Verify recipient received payment
+    assert_eq!(context.zro_token_client.balance(&recipient), 50);
+
+    // Verify refund (100 - 50 = 50)
+    assert_eq!(context.zro_token_client.balance(&refund_address), 50);
+}
+
+#[test]
+fn test_pay_mixed_native_and_zro_fees() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+    let native_recipient = Address::generate(env);
+    let zro_recipient = Address::generate(env);
+    let refund_address = Address::generate(env);
+
+    // Setup: Set ZRO token
+    context.mock_owner_auth("set_zro", (&context.zro_token_client.address,));
+    endpoint_client.set_zro(&context.zro_token_client.address);
+
+    // Mint both types of tokens
+    context.mint_native(&endpoint_client.address, 100);
+    context.mint_zro(&endpoint_client.address, 50);
+
+    let mut native_fee_recipients = Vec::new(env);
+    native_fee_recipients.push_back(FeeRecipient { address: native_recipient.clone(), amount: 100 });
+    let mut zro_fee_recipients = Vec::new(env);
+    zro_fee_recipients.push_back(FeeRecipient { address: zro_recipient.clone(), amount: 50 });
+    let send_result = FeesAndPacket { native_fee_recipients, zro_fee_recipients, encoded_packet: Bytes::new(env) };
+
+    let fee = env.as_contract(&endpoint_client.address, || {
+        EndpointV2::pay_messaging_fees(
+            env,
+            true,
+            &send_result.native_fee_recipients,
+            &send_result.zro_fee_recipients,
+            &refund_address,
+        )
+    });
+
+    // Verify fees were calculated correctly
+    assert_eq!(fee.native_fee, 100);
+    assert_eq!(fee.zro_fee, 50);
+
+    // Verify recipients received payments
+    assert_eq!(context.native_token_client.balance(&native_recipient), 100);
+    assert_eq!(context.zro_token_client.balance(&zro_recipient), 50);
+
+    // Verify no refunds
+    assert_eq!(context.native_token_client.balance(&refund_address), 0);
+    assert_eq!(context.zro_token_client.balance(&refund_address), 0);
+}
+
+#[test]
+fn test_pay_multiple_recipients_same_token() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+    let recipient1 = Address::generate(env);
+    let recipient2 = Address::generate(env);
+    let recipient3 = Address::generate(env);
+    let refund_address = Address::generate(env);
+
+    // Setup: Mint native tokens
+    context.mint_native(&endpoint_client.address, 300);
+
+    let mut native_fee_recipients = Vec::new(env);
+    native_fee_recipients.push_back(FeeRecipient { address: recipient1.clone(), amount: 100 });
+    native_fee_recipients.push_back(FeeRecipient { address: recipient2.clone(), amount: 150 });
+    native_fee_recipients.push_back(FeeRecipient { address: recipient3.clone(), amount: 50 });
+    let send_result =
+        FeesAndPacket { native_fee_recipients, zro_fee_recipients: Vec::new(env), encoded_packet: Bytes::new(env) };
+
+    let fee = env.as_contract(&endpoint_client.address, || {
+        EndpointV2::pay_messaging_fees(
+            env,
+            false,
+            &send_result.native_fee_recipients,
+            &send_result.zro_fee_recipients,
+            &refund_address,
+        )
+    });
+
+    // Verify total fee
+    assert_eq!(fee.native_fee, 300);
+    assert_eq!(fee.zro_fee, 0);
+
+    // Verify each recipient received correct amount
+    assert_eq!(context.native_token_client.balance(&recipient1), 100);
+    assert_eq!(context.native_token_client.balance(&recipient2), 150);
+    assert_eq!(context.native_token_client.balance(&recipient3), 50);
+
+    // Verify no refund
+    assert_eq!(context.native_token_client.balance(&refund_address), 0);
+}
+
+#[test]
+fn test_pay_fees_with_zero_amounts_skipped() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+    let recipient1 = Address::generate(env);
+    let recipient2 = Address::generate(env);
+    let refund_address = Address::generate(env);
+
+    // Setup: Mint native tokens
+    context.mint_native(&endpoint_client.address, 100);
+
+    let mut native_fee_recipients = Vec::new(env);
+    native_fee_recipients.push_back(FeeRecipient { address: recipient1.clone(), amount: 100 });
+    native_fee_recipients.push_back(FeeRecipient { address: recipient2.clone(), amount: 0 }); // Zero amount
+    let send_result =
+        FeesAndPacket { native_fee_recipients, zro_fee_recipients: Vec::new(env), encoded_packet: Bytes::new(env) };
+
+    let fee = env.as_contract(&endpoint_client.address, || {
+        EndpointV2::pay_messaging_fees(
+            env,
+            false,
+            &send_result.native_fee_recipients,
+            &send_result.zro_fee_recipients,
+            &refund_address,
+        )
+    });
+
+    // Verify only non-zero fees were paid
+    assert_eq!(fee.native_fee, 100);
+    assert_eq!(context.native_token_client.balance(&recipient1), 100);
+    assert_eq!(context.native_token_client.balance(&recipient2), 0);
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #6)")]
+fn test_panic_pay_native_fees_insufficient_balance() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+    let recipient = Address::generate(env);
+    let refund_address = Address::generate(env);
+
+    // Setup: Mint less than required
+    context.mint_native(&endpoint_client.address, 50);
+
+    let mut native_fee_recipients = Vec::new(env);
+    native_fee_recipients.push_back(FeeRecipient { address: recipient.clone(), amount: 100 });
+    let send_result =
+        FeesAndPacket { native_fee_recipients, zro_fee_recipients: Vec::new(env), encoded_packet: Bytes::new(env) };
+
+    // Should panic with InsufficientNativeFee error (code 27)
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::pay_messaging_fees(
+            env,
+            false,
+            &send_result.native_fee_recipients,
+            &send_result.zro_fee_recipients,
+            &refund_address,
+        )
+    });
+}
+
+#[test]
+#[should_panic(expected = "Error(Contract, #7)")]
+fn test_panic_pay_zro_fees_insufficient_balance() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+    let recipient = Address::generate(env);
+    let refund_address = Address::generate(env);
+
+    // Setup: Set ZRO token
+    context.mock_owner_auth("set_zro", (&context.zro_token_client.address,));
+    endpoint_client.set_zro(&context.zro_token_client.address);
+
+    // Mint less ZRO than required
+    context.mint_zro(&endpoint_client.address, 25);
+
+    let mut zro_fee_recipients = Vec::new(env);
+    zro_fee_recipients.push_back(FeeRecipient { address: recipient.clone(), amount: 50 });
+    let send_result =
+        FeesAndPacket { native_fee_recipients: Vec::new(env), zro_fee_recipients, encoded_packet: Bytes::new(env) };
+
+    // Should panic with InsufficientZroFee error (code 28)
+    env.as_contract(&endpoint_client.address, || {
+        EndpointV2::pay_messaging_fees(
+            env,
+            true,
+            &send_result.native_fee_recipients,
+            &send_result.zro_fee_recipients,
+            &refund_address,
+        )
+    });
+}
+
+#[test]
+fn test_pay_fees_with_empty_recipients() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+    let refund_address = Address::generate(env);
+
+    // Setup: Mint tokens
+    context.mint_native(&endpoint_client.address, 100);
+
+    let send_result = FeesAndPacket {
+        native_fee_recipients: Vec::new(env),
+        zro_fee_recipients: Vec::new(env),
+        encoded_packet: Bytes::new(env),
+    };
+
+    let fee = env.as_contract(&endpoint_client.address, || {
+        EndpointV2::pay_messaging_fees(
+            env,
+            false,
+            &send_result.native_fee_recipients,
+            &send_result.zro_fee_recipients,
+            &refund_address,
+        )
+    });
+
+    // Verify no fees paid
+    assert_eq!(fee.native_fee, 0);
+    assert_eq!(fee.zro_fee, 0);
+
+    // Verify all balance refunded
+    assert_eq!(context.native_token_client.balance(&refund_address), 100);
+}
+
+#[test]
+fn test_pay_fees_with_mixed_zero_and_nonzero_amounts() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_client = &context.endpoint_client;
+    let recipient1 = Address::generate(env);
+    let recipient2 = Address::generate(env);
+    let recipient3 = Address::generate(env);
+    let refund_address = Address::generate(env);
+
+    // Setup
+    context.mock_owner_auth("set_zro", (&context.zro_token_client.address,));
+    endpoint_client.set_zro(&context.zro_token_client.address);
+    context.mint_native(&endpoint_client.address, 150);
+    context.mint_zro(&endpoint_client.address, 75);
+
+    let mut native_fee_recipients = Vec::new(env);
+    native_fee_recipients.push_back(FeeRecipient { address: recipient1.clone(), amount: 100 });
+    let mut zro_fee_recipients = Vec::new(env);
+    zro_fee_recipients.push_back(FeeRecipient { address: recipient2.clone(), amount: 0 }); // Zero ZRO
+    zro_fee_recipients.push_back(FeeRecipient { address: recipient3.clone(), amount: 50 });
+    let send_result = FeesAndPacket { native_fee_recipients, zro_fee_recipients, encoded_packet: Bytes::new(env) };
+
+    let fee = env.as_contract(&endpoint_client.address, || {
+        EndpointV2::pay_messaging_fees(
+            env,
+            true,
+            &send_result.native_fee_recipients,
+            &send_result.zro_fee_recipients,
+            &refund_address,
+        )
+    });
+
+    // Verify fees
+    assert_eq!(fee.native_fee, 100);
+    assert_eq!(fee.zro_fee, 50);
+
+    // Verify payments
+    assert_eq!(context.native_token_client.balance(&recipient1), 100);
+    assert_eq!(context.zro_token_client.balance(&recipient2), 0);
+    assert_eq!(context.zro_token_client.balance(&recipient3), 50);
+
+    // Verify refunds (150-100=50 native, 75-50=25 zro)
+    assert_eq!(context.native_token_client.balance(&refund_address), 50);
+    assert_eq!(context.zro_token_client.balance(&refund_address), 25);
+}