@layerzerolabs/oft-core-stellar-contracts 0.2.122

package/src/tests/test_msg_inspector.rs

@@ -0,0 +1,324 @@
+//! Tests for the OApp Message Inspector feature.
+
+use crate::tests::test_utils::{create_send_param, OFTTestSetup};
+use common_macros::contract_error;
+use endpoint_v2::MessagingFee;
+use oapp::IOAppMsgInspector;
+use soroban_sdk::{
+    contract, contractimpl, panic_with_error,
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    Address, Bytes, BytesN, Env, IntoVal,
+};
+
+// ==================== Mock Inspector Contracts ====================
+
+/// A mock inspector that always passes (does nothing)
+#[contract]
+pub struct PassingInspector;
+
+#[contractimpl]
+impl IOAppMsgInspector for PassingInspector {
+    fn inspect(_env: &Env, _oapp: &Address, _message: &Bytes, _options: &Bytes) -> bool {
+        // Do nothing - inspection passes
+        true
+    }
+}
+
+#[contract_error]
+pub enum InspectorError {
+    InspectionFailed = 1,
+}
+
+/// A mock inspector that always fails (panics)
+#[contract]
+pub struct FailingInspector;
+
+#[contractimpl]
+impl IOAppMsgInspector for FailingInspector {
+    fn inspect(env: &Env, _oapp: &Address, _message: &Bytes, _options: &Bytes) -> bool {
+        panic_with_error!(env, InspectorError::InspectionFailed);
+    }
+}
+
+// ==================== Storage Tests ====================
+
+#[test]
+fn test_msg_inspector_not_set_by_default() {
+    let env = Env::default();
+    let setup = OFTTestSetup::new(&env);
+
+    // msg_inspector should be None by default
+    let inspector = setup.oft.msg_inspector();
+    assert_eq!(inspector, None);
+}
+
+#[test]
+fn test_set_msg_inspector() {
+    let env = Env::default();
+    let setup = OFTTestSetup::new(&env);
+
+    // Deploy a passing inspector
+    let inspector_address = env.register(PassingInspector, ());
+
+    // Owner (authorizer) sets the inspector
+    env.mock_auths(&[MockAuth {
+        address: &setup.owner,
+        invoke: &MockAuthInvoke {
+            contract: &setup.oft.address,
+            fn_name: "set_msg_inspector",
+            args: (&Some(inspector_address.clone()), &setup.owner).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    setup.oft.set_msg_inspector(&Some(inspector_address.clone()), &setup.owner);
+
+    // Verify inspector is set
+    let stored_inspector = setup.oft.msg_inspector();
+    assert_eq!(stored_inspector, Some(inspector_address));
+}
+
+#[test]
+fn test_remove_msg_inspector() {
+    let env = Env::default();
+    let setup = OFTTestSetup::new(&env);
+
+    // Deploy and set a passing inspector first
+    let inspector_address = env.register(PassingInspector, ());
+
+    env.mock_auths(&[MockAuth {
+        address: &setup.owner,
+        invoke: &MockAuthInvoke {
+            contract: &setup.oft.address,
+            fn_name: "set_msg_inspector",
+            args: (&Some(inspector_address.clone()), &setup.owner).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    setup.oft.set_msg_inspector(&Some(inspector_address), &setup.owner);
+
+    // Verify it's set
+    assert!(setup.oft.msg_inspector().is_some());
+
+    // Remove the inspector by setting to None
+    env.mock_auths(&[MockAuth {
+        address: &setup.owner,
+        invoke: &MockAuthInvoke {
+            contract: &setup.oft.address,
+            fn_name: "set_msg_inspector",
+            args: (&None::<Address>, &setup.owner).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    setup.oft.set_msg_inspector(&None, &setup.owner);
+
+    // Verify inspector is removed
+    let stored_inspector = setup.oft.msg_inspector();
+    assert_eq!(stored_inspector, None);
+}
+
+// ==================== Access Control Tests ====================
+
+#[test]
+#[should_panic(expected = "Error(Contract, #1086)")] // RbacError::Unauthorized
+fn test_set_msg_inspector_requires_owner() {
+    let env = Env::default();
+    let setup = OFTTestSetup::new(&env);
+
+    // Deploy a passing inspector
+    let inspector_address = env.register(PassingInspector, ());
+
+    // Non-owner (not the authorizer) tries to set the inspector
+    let non_owner = Address::generate(&env);
+    env.mock_auths(&[MockAuth {
+        address: &non_owner,
+        invoke: &MockAuthInvoke {
+            contract: &setup.oft.address,
+            fn_name: "set_msg_inspector",
+            args: (&Some(inspector_address.clone()), &non_owner).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    // This should panic because non_owner is not the authorizer
+    setup.oft.set_msg_inspector(&Some(inspector_address), &non_owner);
+}
+
+// ==================== Integration Tests with Send ====================
+
+#[test]
+fn test_send_without_inspector_succeeds() {
+    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);
+
+    let amount_ld = 12345670i128;
+    setup.fund_tokens(&sender, amount_ld);
+    setup.fund_native_fees(&sender, setup.native_fee);
+
+    let send_param = create_send_param(&env, dst_eid, amount_ld, amount_ld);
+    let fee = MessagingFee { native_fee: setup.native_fee, zro_fee: 0 };
+    let oft_receipt = setup.quote_oft(&sender, &send_param);
+
+    // Send without inspector set - should succeed
+    let (msg_receipt, oft_receipt) = setup.send(&sender, &send_param, &fee, &sender, &oft_receipt);
+
+    assert!(msg_receipt.nonce > 0);
+    assert_eq!(oft_receipt.amount_sent_ld, amount_ld);
+}
+
+#[test]
+fn test_send_with_passing_inspector() {
+    let env = Env::default();
+    let setup = OFTTestSetup::new(&env);
+
+    // Deploy and set a passing inspector
+    let inspector_address = env.register(PassingInspector, ());
+    env.mock_auths(&[MockAuth {
+        address: &setup.owner,
+        invoke: &MockAuthInvoke {
+            contract: &setup.oft.address,
+            fn_name: "set_msg_inspector",
+            args: (&Some(inspector_address.clone()), &setup.owner).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    setup.oft.set_msg_inspector(&Some(inspector_address), &setup.owner);
+
+    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);
+
+    let amount_ld = 12345670i128;
+    setup.fund_tokens(&sender, amount_ld);
+    setup.fund_native_fees(&sender, setup.native_fee);
+
+    let send_param = create_send_param(&env, dst_eid, amount_ld, amount_ld);
+    let fee = MessagingFee { native_fee: setup.native_fee, zro_fee: 0 };
+    let oft_receipt = setup.quote_oft(&sender, &send_param);
+
+    // Send with passing inspector - should succeed
+    let (msg_receipt, oft_receipt) = setup.send(&sender, &send_param, &fee, &sender, &oft_receipt);
+
+    assert!(msg_receipt.nonce > 0);
+    assert_eq!(oft_receipt.amount_sent_ld, amount_ld);
+}
+
+#[test]
+fn test_send_with_failing_inspector() {
+    let env = Env::default();
+    let setup = OFTTestSetup::new(&env);
+
+    // Deploy and set a failing inspector
+    let inspector_address = env.register(FailingInspector, ());
+    env.mock_auths(&[MockAuth {
+        address: &setup.owner,
+        invoke: &MockAuthInvoke {
+            contract: &setup.oft.address,
+            fn_name: "set_msg_inspector",
+            args: (&Some(inspector_address.clone()), &setup.owner).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    setup.oft.set_msg_inspector(&Some(inspector_address), &setup.owner);
+
+    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);
+
+    let amount_ld = 12345670i128;
+    setup.fund_tokens(&sender, amount_ld);
+    setup.fund_native_fees(&sender, setup.native_fee);
+
+    let send_param = create_send_param(&env, dst_eid, amount_ld, amount_ld);
+    let fee = MessagingFee { native_fee: setup.native_fee, zro_fee: 0 };
+    let oft_receipt = setup.quote_oft(&sender, &send_param);
+
+    // Send with failing inspector - should fail
+    let result = setup.try_send(&sender, &send_param, &fee, &sender, &oft_receipt);
+
+    // Verify the send failed due to inspector
+    assert!(result.is_err() || result.unwrap().is_err());
+}
+
+// ==================== Integration Tests with Quote ====================
+
+#[test]
+fn test_quote_send_with_passing_inspector() {
+    let env = Env::default();
+    let setup = OFTTestSetup::new(&env);
+
+    // Deploy and set a passing inspector
+    let inspector_address = env.register(PassingInspector, ());
+    env.mock_auths(&[MockAuth {
+        address: &setup.owner,
+        invoke: &MockAuthInvoke {
+            contract: &setup.oft.address,
+            fn_name: "set_msg_inspector",
+            args: (&Some(inspector_address.clone()), &setup.owner).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    setup.oft.set_msg_inspector(&Some(inspector_address), &setup.owner);
+
+    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);
+
+    let amount_ld = 12345670i128;
+    let send_param = create_send_param(&env, dst_eid, amount_ld, amount_ld);
+
+    // Quote with passing inspector - should succeed
+    let fee = setup.oft.quote_send(&sender, &send_param, &false);
+
+    assert!(fee.native_fee > 0);
+}
+
+#[test]
+fn test_quote_send_with_failing_inspector() {
+    let env = Env::default();
+    let setup = OFTTestSetup::new(&env);
+
+    // Deploy and set a failing inspector
+    let inspector_address = env.register(FailingInspector, ());
+    env.mock_auths(&[MockAuth {
+        address: &setup.owner,
+        invoke: &MockAuthInvoke {
+            contract: &setup.oft.address,
+            fn_name: "set_msg_inspector",
+            args: (&Some(inspector_address.clone()), &setup.owner).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    setup.oft.set_msg_inspector(&Some(inspector_address), &setup.owner);
+
+    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);
+
+    let amount_ld = 12345670i128;
+    let send_param = create_send_param(&env, dst_eid, amount_ld, amount_ld);
+
+    // Quote with failing inspector - should fail
+    let result = setup.oft.try_quote_send(&sender, &send_param, &false);
+
+    // Verify the quote failed due to inspector
+    assert!(result.is_err());
+}

package/src/tests/test_oft_compose_msg_codec.rs

@@ -0,0 +1,68 @@
+use crate::codec::oft_compose_msg_codec::OFTComposeMsg;
+use soroban_sdk::{Bytes, BytesN, Env};
+
+#[test]
+fn test_encode_and_decode_basic() {
+    let env = Env::default();
+    let nonce = 12345u64;
+    let src_eid = 101u32;
+    let amount_ld = 1_000_000_000i128; // 1 token with 9 decimals
+    let compose_from = BytesN::from_array(&env, &[0x42u8; 32]);
+    let compose_msg = Bytes::from_array(&env, b"test compose message");
+
+    let msg = OFTComposeMsg {
+        nonce,
+        src_eid,
+        amount_ld,
+        compose_from: compose_from.clone(),
+        compose_msg: compose_msg.clone(),
+    };
+
+    let encoded = msg.encode(&env);
+    let decoded = OFTComposeMsg::decode(&encoded);
+
+    assert_eq!(decoded.nonce, nonce);
+    assert_eq!(decoded.src_eid, src_eid);
+    assert_eq!(decoded.amount_ld, amount_ld);
+    assert_eq!(decoded.compose_from, compose_from);
+    assert_eq!(decoded.compose_msg, compose_msg);
+}
+
+#[test]
+fn test_encode_with_empty_compose_msg() {
+    let env = Env::default();
+    let nonce = 123u64;
+    let src_eid = 1u32;
+    let amount_ld = 1_000_000i128;
+    let compose_from = BytesN::from_array(&env, &[0x11u8; 32]);
+    let compose_msg = Bytes::new(&env); // Empty
+
+    let msg = OFTComposeMsg { nonce, src_eid, amount_ld, compose_from: compose_from.clone(), compose_msg };
+
+    let encoded = msg.encode(&env);
+    let decoded = OFTComposeMsg::decode(&encoded);
+
+    assert_eq!(decoded.nonce, nonce);
+    assert_eq!(decoded.src_eid, src_eid);
+    assert_eq!(decoded.amount_ld, amount_ld);
+    assert_eq!(decoded.compose_from, compose_from);
+    assert_eq!(decoded.compose_msg.len(), 0);
+}
+
+#[test]
+#[should_panic]
+fn test_decode_panic_on_empty_data() {
+    let env = Env::default();
+    let data = Bytes::new(&env);
+    OFTComposeMsg::decode(&data);
+}
+
+#[test]
+#[should_panic]
+fn test_decode_panic_on_insufficient_data() {
+    let env = Env::default();
+    let mut data = Bytes::new(&env);
+    // Only 30 bytes - not enough for nonce(8) + src_eid(4) + amount_ld(16) + compose_from(32) = 60 bytes minimum
+    data.extend_from_array(&[0u8; 30]);
+    OFTComposeMsg::decode(&data);
+}

package/src/tests/test_oft_msg_codec.rs

@@ -0,0 +1,64 @@
+use crate::codec::oft_msg_codec::{ComposeData, OFTMessage};
+use crate::utils::address_payload;
+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: None };
+    let encoded = msg.encode(&env);
+
+    // 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!(decoded.compose.is_none());
+}
+
+#[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: Some(ComposeData { from: address_payload(&env, &sender), msg: compose_msg_val }),
+    };
+    let encoded = msg.encode(&env);
+
+    // Test decode function
+    let decoded = OFTMessage::decode(&encoded);
+    assert_eq!(decoded.send_to, send_to_addr);
+    assert_eq!(decoded.amount_sd, amount_sd_val);
+    let compose = decoded.compose.as_ref().unwrap();
+    assert_eq!(compose.msg.len(), 4);
+
+    // Verify compose message structure: sender's bytes32 (32 bytes) + compose_msg (4 bytes)
+    let compose_from_len = compose.from.to_array().len() as u32;
+    let compose_msg_len = compose.msg.len();
+    assert_eq!(compose_from_len + compose_msg_len, 36);
+}
+
+#[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/src/tests/test_oft_version_and_approval.rs

@@ -0,0 +1,22 @@
+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);
+}
+
+#[test]
+fn test_approval_required_returns_false_by_default() {
+    let env = Env::default();
+    let setup = OFTTestSetup::new(&env);
+
+    // Default OFTCore behavior: no separate token approval is required.
+    assert!(!setup.oft.approval_required());
+}

package/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(&setup.owner, &send_param);
+
+    // Check limits
+    assert_eq!(limit.min_amount_ld, 0);
+    assert_eq!(limit.max_amount_ld, u64::MAX as i128);
+
+    // 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(&setup.owner, &send_param);
+
+    // Check limits
+    assert_eq!(limit.min_amount_ld, 0);
+    assert_eq!(limit.max_amount_ld, u64::MAX as i128);
+
+    // 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(&setup.owner, &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, u64::MAX as i128);
+    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(&setup.owner, &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(&setup.owner, &send_param);
+
+        // Results should be the same regardless of dst_eid
+        assert_eq!(limit.min_amount_ld, 0);
+        assert_eq!(limit.max_amount_ld, u64::MAX as i128);
+        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(&setup.owner, &send_param);
+
+    assert_eq!(limit.min_amount_ld, 0);
+    assert_eq!(limit.max_amount_ld, u64::MAX as i128);
+    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(&setup.owner, &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(&setup.owner, &send_param);
+    assert_eq!(result.err().unwrap().ok().unwrap(), OFTError::SlippageExceeded.into());
+}