@layerzerolabs/protocol-stellar-v2 0.2.8 → 0.2.9

package/contracts/oapps/oft/src/tests/test_oft_msg_codec.rs

@@ -0,0 +1,136 @@
+use crate::codec::oft_msg_codec::OFTMessage;
+use crate::utils::address_to_bytes32;
+use soroban_sdk::{testutils::Address as _, Address, Bytes, BytesN, Env};
+
+#[test]
+fn test_encode_and_decode_without_compose() {
+    let env = Env::default();
+    let send_to_addr = BytesN::from_array(&env, &[1u8; 32]);
+    let amount_sd_val = 1000u64;
+
+    let msg =
+        OFTMessage { send_to: send_to_addr.clone(), amount_sd: amount_sd_val, compose_from: None, compose_msg: None };
+    let (encoded, has_compose) = msg.encode(&env);
+
+    assert_eq!(has_compose, false);
+
+    // Test decode function
+    let decoded = OFTMessage::decode(&encoded);
+    assert_eq!(decoded.send_to, send_to_addr);
+    assert_eq!(decoded.amount_sd, amount_sd_val);
+    assert_eq!(decoded.compose_from.is_none(), true);
+    assert_eq!(decoded.compose_msg.is_none(), true);
+    assert_eq!(decoded.is_composed(), false);
+}
+
+#[test]
+fn test_encode_and_decode_with_compose() {
+    let env = Env::default();
+    let sender = Address::generate(&env);
+    let send_to_addr = BytesN::from_array(&env, &[2u8; 32]);
+    let amount_sd_val = 5000u64;
+    let compose_msg_val = Bytes::from_array(&env, &[1u8, 2u8, 3u8, 4u8]);
+
+    let msg = OFTMessage {
+        send_to: send_to_addr.clone(),
+        amount_sd: amount_sd_val,
+        compose_from: Some(address_to_bytes32(&sender)),
+        compose_msg: Some(compose_msg_val),
+    };
+    let (encoded, has_compose) = msg.encode(&env);
+
+    assert_eq!(has_compose, true);
+
+    // Test decode function
+    let decoded = OFTMessage::decode(&encoded);
+    assert_eq!(decoded.send_to, send_to_addr);
+    assert_eq!(decoded.amount_sd, amount_sd_val);
+    assert_eq!(decoded.compose_from.is_some(), true);
+    assert_eq!(decoded.compose_msg.is_some(), true);
+    assert_eq!(decoded.compose_msg.as_ref().unwrap().len(), 4);
+    assert_eq!(decoded.is_composed(), true);
+
+    // Verify compose message structure: sender's bytes32 (32 bytes) + compose_msg (4 bytes)
+    let compose_from_len = decoded.compose_from.as_ref().unwrap().to_array().len() as u32;
+    let compose_msg_len = decoded.compose_msg.as_ref().unwrap().len();
+    assert_eq!(compose_from_len + compose_msg_len, 36);
+}
+
+#[test]
+fn test_is_composed_false_when_only_compose_from() {
+    let env = Env::default();
+    let sender = Address::generate(&env);
+    let send_to_addr = BytesN::from_array(&env, &[1u8; 32]);
+    let amount_sd_val = 100u64;
+
+    // Manually construct invalid state: only compose_from, no compose_msg
+    let msg = OFTMessage {
+        send_to: send_to_addr,
+        amount_sd: amount_sd_val,
+        compose_from: Some(address_to_bytes32(&sender)),
+        compose_msg: None,
+    };
+
+    // Should return false - both fields are required for compose
+    assert_eq!(msg.is_composed(), false);
+}
+
+#[test]
+fn test_is_composed_false_when_only_compose_msg() {
+    let env = Env::default();
+    let send_to_addr = BytesN::from_array(&env, &[1u8; 32]);
+    let amount_sd_val = 100u64;
+    let compose_msg_val = Bytes::from_array(&env, &[1u8, 2u8, 3u8]);
+
+    // Manually construct invalid state: only compose_msg, no compose_from
+    let msg = OFTMessage {
+        send_to: send_to_addr,
+        amount_sd: amount_sd_val,
+        compose_from: None,
+        compose_msg: Some(compose_msg_val),
+    };
+
+    // Should return false - both fields are required for compose
+    assert_eq!(msg.is_composed(), false);
+}
+
+#[test]
+fn test_is_composed_false_when_compose_msg_empty() {
+    let env = Env::default();
+    let sender = Address::generate(&env);
+    let send_to_addr = BytesN::from_array(&env, &[1u8; 32]);
+    let amount_sd_val = 100u64;
+    let empty_compose_msg = Bytes::new(&env); // Empty bytes, not None
+
+    // Manually construct state with empty compose_msg
+    let msg = OFTMessage {
+        send_to: send_to_addr.clone(),
+        amount_sd: amount_sd_val,
+        compose_from: Some(address_to_bytes32(&sender)),
+        compose_msg: Some(empty_compose_msg),
+    };
+
+    // Should return false - compose_msg must have data
+    assert_eq!(msg.is_composed(), false);
+
+    // Verify encoding also treats it as non-composed
+    let (_, has_compose) = msg.encode(&env);
+    assert_eq!(has_compose, false);
+}
+
+#[test]
+#[should_panic]
+fn test_decode_panic_on_empty_data() {
+    let env = Env::default();
+    let data = Bytes::new(&env);
+    OFTMessage::decode(&data);
+}
+
+#[test]
+#[should_panic]
+fn test_decode_panic_on_insufficient_data() {
+    let env = Env::default();
+    let mut data = Bytes::new(&env);
+    data.extend_from_array(&[0u8; 20]); // Not enough data for amount_sd
+    OFTMessage::decode(&data);
+}

package/contracts/oapps/oft/src/tests/test_oft_version.rs

@@ -0,0 +1,13 @@
+use soroban_sdk::Env;
+
+use super::test_utils::OFTTestSetup;
+
+#[test]
+fn test_oft_version_returns_correct_values() {
+    let env = Env::default();
+    let setup = OFTTestSetup::new(&env);
+
+    let (major, minor) = setup.oft.oft_version();
+    assert_eq!(major, 1);
+    assert_eq!(minor, 1);
+}

package/contracts/oapps/oft/src/tests/test_quote_oft.rs

@@ -0,0 +1,159 @@
+use crate::errors::OFTError;
+use soroban_sdk::Env;
+
+use super::test_utils::{create_send_param, OFTTestSetup};
+
+// ==================== Basic Quote OFT Tests ====================
+
+#[test]
+fn test_quote_oft_basic() {
+    let env = Env::default();
+    let setup = OFTTestSetup::new(&env);
+
+    let conversion_rate = setup.oft.decimal_conversion_rate();
+    let amount_ld = 12345670i128;
+    let dust_removed = (amount_ld / conversion_rate) * conversion_rate; // No dust with last digit 0
+    let send_param = create_send_param(&env, 1, amount_ld, dust_removed);
+
+    let (limit, fees, receipt) = setup.oft.quote_oft(&send_param);
+
+    // Check limits
+    assert_eq!(limit.min_amount_ld, 0);
+    assert_eq!(limit.max_amount_ld, i128::MAX);
+
+    // Check fees (should be empty for basic OFT)
+    assert_eq!(fees.len(), 0);
+
+    // Check receipt
+    assert_eq!(receipt.amount_sent_ld, dust_removed);
+    assert_eq!(receipt.amount_received_ld, dust_removed);
+}
+
+#[test]
+fn test_quote_oft_with_dust_removal() {
+    let env = Env::default();
+    let setup = OFTTestSetup::new(&env);
+
+    let conversion_rate = setup.oft.decimal_conversion_rate();
+    // Amount with dust that will be removed
+    let amount_ld = 12345678i128;
+    let dust_removed = (amount_ld / conversion_rate) * conversion_rate;
+    let send_param = create_send_param(&env, 1, amount_ld, dust_removed);
+
+    let (limit, fees, receipt) = setup.oft.quote_oft(&send_param);
+
+    // Check limits
+    assert_eq!(limit.min_amount_ld, 0);
+    assert_eq!(limit.max_amount_ld, i128::MAX);
+
+    // Check fees (should be empty for basic OFT)
+    assert_eq!(fees.len(), 0);
+
+    // Check receipt - dust removed
+    assert_eq!(receipt.amount_sent_ld, dust_removed);
+    assert_eq!(receipt.amount_received_ld, dust_removed);
+}
+
+#[test]
+fn test_quote_oft_zero_amount() {
+    let env = Env::default();
+    let setup = OFTTestSetup::new(&env);
+
+    let send_param = create_send_param(&env, 1, 0, 0);
+
+    let (limit, fees, receipt) = setup.oft.quote_oft(&send_param);
+
+    assert_eq!(receipt.amount_sent_ld, 0);
+    assert_eq!(receipt.amount_received_ld, 0);
+    assert_eq!(limit.min_amount_ld, 0);
+    assert_eq!(limit.max_amount_ld, i128::MAX);
+    assert_eq!(fees.len(), 0);
+}
+
+#[test]
+fn test_quote_oft_dust_only_amount() {
+    let env = Env::default();
+    let setup = OFTTestSetup::new(&env);
+
+    let conversion_rate = setup.oft.decimal_conversion_rate();
+    // Amount that is entirely dust (less than conversion rate)
+    let amount_ld = conversion_rate - 1; // Less than conversion rate
+    let send_param = create_send_param(&env, 1, amount_ld, 0);
+
+    let (_, _, receipt) = setup.oft.quote_oft(&send_param);
+
+    // All dust should be removed
+    assert_eq!(receipt.amount_sent_ld, 0);
+    assert_eq!(receipt.amount_received_ld, 0);
+}
+
+#[test]
+fn test_quote_oft_different_dst_eids() {
+    let env = Env::default();
+    let setup = OFTTestSetup::new(&env);
+
+    let amount_ld = 12345670i128; // No dust
+
+    // Test with different destination EIDs
+    for dst_eid in [1u32, 100, 10000, u32::MAX] {
+        let send_param = create_send_param(&env, dst_eid, amount_ld, amount_ld);
+        let (limit, fees, receipt) = setup.oft.quote_oft(&send_param);
+
+        // Results should be the same regardless of dst_eid
+        assert_eq!(limit.min_amount_ld, 0);
+        assert_eq!(limit.max_amount_ld, i128::MAX);
+        assert_eq!(fees.len(), 0);
+        assert_eq!(receipt.amount_sent_ld, amount_ld);
+        assert_eq!(receipt.amount_received_ld, amount_ld);
+    }
+}
+
+#[test]
+fn test_quote_oft_large_amounts() {
+    let env = Env::default();
+    let setup = OFTTestSetup::new(&env);
+
+    // Test with a large amount
+    let amount_ld = 1_000_000_000_000_000_000i128;
+    let send_param = create_send_param(&env, 1, amount_ld, amount_ld);
+
+    let (limit, fees, receipt) = setup.oft.quote_oft(&send_param);
+
+    assert_eq!(limit.min_amount_ld, 0);
+    assert_eq!(limit.max_amount_ld, i128::MAX);
+    assert_eq!(fees.len(), 0);
+    assert_eq!(receipt.amount_sent_ld, amount_ld);
+    assert_eq!(receipt.amount_received_ld, amount_ld);
+}
+
+// ==================== Slippage Tests ====================
+
+#[test]
+fn test_quote_oft_slippage_less_than_received() {
+    let env = Env::default();
+    let setup = OFTTestSetup::new(&env);
+
+    let conversion_rate = setup.oft.decimal_conversion_rate();
+    let amount_ld = 12345678i128;
+    let dust_removed = (amount_ld / conversion_rate) * conversion_rate;
+    // min_amount_ld is less than what will be received
+    let send_param = create_send_param(&env, 1, amount_ld, dust_removed - conversion_rate);
+
+    let (_, _, receipt) = setup.oft.quote_oft(&send_param);
+
+    assert_eq!(receipt.amount_sent_ld, dust_removed);
+    assert_eq!(receipt.amount_received_ld, dust_removed);
+}
+
+#[test]
+fn test_quote_oft_slippage_exceeded() {
+    let env = Env::default();
+    let setup = OFTTestSetup::new(&env);
+
+    let amount_ld = 12345678i128;
+    // min_amount_ld is higher than what can be received after dust removal
+    let send_param = create_send_param(&env, 1, amount_ld, amount_ld);
+
+    let result = setup.oft.try_quote_oft(&send_param);
+    assert_eq!(result.err().unwrap().ok().unwrap(), OFTError::SlippageExceeded.into());
+}

package/contracts/oapps/oft/src/tests/test_quote_send.rs

@@ -0,0 +1,195 @@
+use crate::{errors::OFTError, types::SendParam};
+use oapp::errors::OAppError;
+use soroban_sdk::{bytes, testutils::Address as _, Address, Bytes, BytesN, Env};
+
+use super::test_utils::{create_send_param, OFTTestSetup};
+
+#[test]
+fn test_quote_send_basic() {
+    let env = Env::default();
+    let setup = OFTTestSetup::new(&env);
+
+    let sender = Address::generate(&env);
+
+    // Set peer
+    let peer = BytesN::from_array(&env, &[2u8; 32]);
+    let dst_eid = 100u32;
+    setup.set_peer(dst_eid, &peer);
+
+    // SAC has 7 decimals, shared is 6, conversion rate = 10
+    // Use amount with no dust
+    let amount_ld = 12345670i128;
+    let send_param = create_send_param(&env, dst_eid, amount_ld, amount_ld);
+
+    // Quote send without ZRO
+    let fee = setup.oft.quote_send(&sender, &send_param, &false);
+    assert_eq!(fee.native_fee, setup.native_fee);
+    assert_eq!(fee.zro_fee, 0);
+}
+
+#[test]
+fn test_quote_send_with_zro() {
+    let env = Env::default();
+    let setup = OFTTestSetup::new(&env);
+
+    let sender = Address::generate(&env);
+
+    let peer = BytesN::from_array(&env, &[2u8; 32]);
+    let dst_eid = 100u32;
+    setup.set_peer(dst_eid, &peer);
+
+    let amount_ld = 12345670i128;
+    let send_param = create_send_param(&env, dst_eid, amount_ld, amount_ld);
+
+    // Quote send with ZRO
+    let fee = setup.oft.quote_send(&sender, &send_param, &true);
+    assert_eq!(fee.native_fee, setup.native_fee);
+    assert_eq!(fee.zro_fee, setup.zro_fee);
+}
+
+#[test]
+fn test_quote_send_different_amounts() {
+    let env = Env::default();
+    let setup = OFTTestSetup::new(&env);
+
+    let sender = Address::generate(&env);
+
+    let peer = BytesN::from_array(&env, &[2u8; 32]);
+    let dst_eid = 100u32;
+    setup.set_peer(dst_eid, &peer);
+
+    // Test with different amounts (all divisible by conversion rate to avoid dust)
+    let conversion_rate = setup.oft.decimal_conversion_rate();
+    for amount in [100i128, 1000, 10000, 100000, 1000000] {
+        let dust_removed = (amount / conversion_rate) * conversion_rate;
+        let send_param = create_send_param(&env, dst_eid, amount, dust_removed);
+        let fee = setup.oft.quote_send(&sender, &send_param, &false);
+        assert_eq!(fee.native_fee, setup.native_fee);
+    }
+}
+
+#[test]
+fn test_quote_send_multiple_destinations() {
+    let env = Env::default();
+    let setup = OFTTestSetup::new(&env);
+
+    let sender = Address::generate(&env);
+
+    // Set multiple peers
+    let dst_eids = [1u32, 100, 200, 300];
+    for eid in dst_eids.iter() {
+        let peer = BytesN::from_array(&env, &[*eid as u8; 32]);
+        setup.set_peer(*eid, &peer);
+    }
+
+    let amount_ld = 12345670i128;
+
+    // Test quote for each destination
+    for dst_eid in dst_eids.iter() {
+        let send_param = create_send_param(&env, *dst_eid, amount_ld, amount_ld);
+        let fee = setup.oft.quote_send(&sender, &send_param, &false);
+        assert_eq!(fee.native_fee, setup.native_fee);
+        assert_eq!(fee.zro_fee, 0);
+    }
+}
+
+#[test]
+fn test_quote_send_no_peer_set() {
+    let env = Env::default();
+    let setup = OFTTestSetup::new(&env);
+
+    let sender = Address::generate(&env);
+
+    // Don't set peer - should fail
+    let amount_ld = 12345670i128;
+    let send_param = create_send_param(&env, 100, amount_ld, amount_ld);
+
+    let result = setup.oft.try_quote_send(&sender, &send_param, &false);
+    assert_eq!(result.err().unwrap().ok().unwrap(), OAppError::NoPeer.into());
+}
+
+#[test]
+fn test_quote_send_with_compose_msg() {
+    let env = Env::default();
+    let setup = OFTTestSetup::new(&env);
+
+    let sender = Address::generate(&env);
+
+    let peer = BytesN::from_array(&env, &[2u8; 32]);
+    let dst_eid = 100u32;
+    setup.set_peer(dst_eid, &peer);
+
+    // Create send param with compose message
+    let amount_ld = 12345670i128;
+    let send_param = SendParam {
+        dst_eid,
+        to: BytesN::from_array(&env, &[1u8; 32]),
+        amount_ld,
+        min_amount_ld: amount_ld,
+        extra_options: bytes!(&env),
+        compose_msg: Bytes::from_array(&env, b"test compose msg"),
+        oft_cmd: bytes!(&env),
+    };
+
+    let fee = setup.oft.quote_send(&sender, &send_param, &false);
+    assert_eq!(fee.native_fee, setup.native_fee);
+}
+
+#[test]
+fn test_quote_send_slippage_exceeded() {
+    let env = Env::default();
+    let setup = OFTTestSetup::new(&env);
+
+    let sender = Address::generate(&env);
+
+    let peer = BytesN::from_array(&env, &[2u8; 32]);
+    let dst_eid = 100u32;
+    setup.set_peer(dst_eid, &peer);
+
+    let amount_ld = 12345678i128;
+    // min_amount_ld is higher than what can be received after dust removal
+    let send_param = create_send_param(&env, dst_eid, amount_ld, amount_ld);
+
+    let result = setup.oft.try_quote_send(&sender, &send_param, &false);
+    assert_eq!(result.err().unwrap().ok().unwrap(), OFTError::SlippageExceeded.into());
+}
+
+#[test]
+fn test_quote_send_zero_amount() {
+    let env = Env::default();
+    let setup = OFTTestSetup::new(&env);
+
+    let sender = Address::generate(&env);
+
+    let peer = BytesN::from_array(&env, &[2u8; 32]);
+    let dst_eid = 100u32;
+    setup.set_peer(dst_eid, &peer);
+
+    let send_param = create_send_param(&env, dst_eid, 0, 0);
+
+    let fee = setup.oft.quote_send(&sender, &send_param, &false);
+    assert_eq!(fee.native_fee, setup.native_fee);
+    assert_eq!(fee.zro_fee, 0);
+}
+
+#[test]
+fn test_quote_send_with_dust_removal() {
+    let env = Env::default();
+    let setup = OFTTestSetup::new(&env);
+
+    let sender = Address::generate(&env);
+
+    let peer = BytesN::from_array(&env, &[2u8; 32]);
+    let dst_eid = 100u32;
+    setup.set_peer(dst_eid, &peer);
+
+    // Amount with dust that will be removed
+    let amount_ld = 12345678i128;
+    let conversion_rate = setup.oft.decimal_conversion_rate();
+    let dust_removed = (amount_ld / conversion_rate) * conversion_rate;
+    let send_param = create_send_param(&env, dst_eid, amount_ld, dust_removed);
+
+    let fee = setup.oft.quote_send(&sender, &send_param, &false);
+    assert_eq!(fee.native_fee, setup.native_fee);
+    assert_eq!(fee.zro_fee, 0);
+}

package/contracts/oapps/oft/src/tests/test_resolve_address.rs

@@ -0,0 +1,37 @@
+use crate::{
+    tests::test_utils::{create_recipient_address, generate_g_address},
+    utils::{address_to_bytes32, resolve_address},
+};
+use soroban_sdk::Env;
+
+#[test]
+fn test_resolve_address_contract_exists() {
+    let env = Env::default();
+
+    // Create a contract address
+    let contract_address = create_recipient_address(&env);
+
+    // Convert to bytes32
+    let bytes32 = address_to_bytes32(&contract_address);
+
+    // Resolve back - should return the same contract address
+    let resolved = resolve_address(&env, &bytes32);
+
+    assert_eq!(resolved, contract_address);
+}
+
+#[test]
+fn test_resolve_address_contract_not_exists_fallback_to_g_address() {
+    let env = Env::default();
+
+    // Create a G-address (account address)
+    let g_address = generate_g_address(&env);
+
+    // Convert to bytes32
+    let bytes32 = address_to_bytes32(&g_address);
+
+    // Resolve - should fallback to G-address since contract doesn't exist
+    let resolved = resolve_address(&env, &bytes32);
+
+    assert_eq!(resolved, g_address);
+}