@layerzerolabs/protocol-stellar-v2 0.2.19 → 0.2.21

package/contracts/oapps/oft-core/src/storage.rs

@@ -3,11 +3,15 @@ use soroban_sdk::Address;
 
 #[storage]
 pub enum OFTStorage {
-    /// The decimal conversion rate used for cross-chain normalization
-    #[instance(i128)]
-    DecimalConversionRate,
+    /// The difference between local and shared decimals (local_decimals - shared_decimals)
+    #[instance(u32)]
+    DecimalsDiff,
 
     /// The address of the underlying token contract
     #[instance(Address)]
     Token,
+
+    /// The optional message inspector contract address
+    #[instance(Address)]
+    MsgInspector,
 }

package/contracts/oapps/oft-core/src/tests/mod.rs

@@ -5,6 +5,7 @@ pub mod test_oft_msg_codec;
 
 pub mod test_decimals;
 pub mod test_lz_receive;
+pub mod test_msg_inspector;
 pub mod test_oft_version;
 pub mod test_quote_oft;
 pub mod test_quote_send;

package/contracts/oapps/oft-core/src/tests/test_decimals.rs

@@ -17,7 +17,7 @@ fn test_decimal_conversion_rate() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #3000)")] // InvalidLocalDecimals
+#[should_panic(expected = "Error(Contract, #3001)")] // InvalidLocalDecimals
 fn test_invalid_local_decimals() {
     let env = Env::default();
     OFTTestSetupBuilder::new(&env).with_token_decimals(5).with_shared_decimals(6).build();
@@ -34,7 +34,7 @@ fn test_to_ld_overflow() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #3002)")] // Overflow
+#[should_panic(expected = "Error(Contract, #3003)")] // Overflow
 fn test_to_sd_overflow() {
     let env = Env::default();
 
@@ -87,3 +87,38 @@ fn test_to_sd_truncates_dust() {
     // 20 LD → 2 SD (exact)
     assert_eq!(to_sd(&env, 20, conversion_rate), 2);
 }
+
+// ==================== Shared Decimals Tests ====================
+
+#[test]
+fn test_shared_decimals_default() {
+    let env = Env::default();
+    let setup = OFTTestSetup::new(&env);
+
+    // Default setup: 7 local decimals, 6 shared decimals
+    let shared = setup.oft.shared_decimals();
+    assert_eq!(shared, setup.shared_decimals);
+    assert_eq!(shared, 6);
+}
+
+#[test]
+fn test_shared_decimals_equal_to_local() {
+    let env = Env::default();
+    // When shared_decimals == local_decimals, conversion_rate = 1
+    let setup = OFTTestSetupBuilder::new(&env).with_token_decimals(8).with_shared_decimals(8).build();
+
+    let shared = setup.oft.shared_decimals();
+    assert_eq!(shared, 8);
+    assert_eq!(setup.oft.decimal_conversion_rate(), 1);
+}
+
+#[test]
+fn test_shared_decimals_large_difference() {
+    let env = Env::default();
+    // 18 local decimals, 6 shared decimals → conversion_rate = 10^12
+    let setup = OFTTestSetupBuilder::new(&env).with_token_decimals(18).with_shared_decimals(6).build();
+
+    let shared = setup.oft.shared_decimals();
+    assert_eq!(shared, 6);
+    assert_eq!(setup.oft.decimal_conversion_rate(), 10_i128.pow(12));
+}

package/contracts/oapps/oft-core/src/tests/test_lz_receive.rs

@@ -9,7 +9,7 @@ use crate::{
 };
 use endpoint_v2::LayerZeroReceiverClient;
 use soroban_sdk::{testutils::Address as _, Address, Bytes, BytesN, Env};
-use utils::testing_utils::assert_event;
+use utils::testing_utils::assert_contains_event;
 
 // Helper function to reduce code duplication for lz_receive tests
 fn run_lz_receive_test(setup: &OFTTestSetup, recipient: &Address, amount_sd: u64) {
@@ -37,7 +37,7 @@ fn run_lz_receive_test(setup: &OFTTestSetup, recipient: &Address, amount_sd: u64
     let conversion_rate = setup.oft.decimal_conversion_rate();
     let expected_amount_ld = (amount_sd as i128) * conversion_rate;
     setup.lz_receive(&executor, &origin, &guid, &message, &extra_data, 0);
-    assert_event(
+    assert_contains_event(
         env,
         &setup.oft.address,
         OFTReceived { guid: guid.clone(), src_eid, to: recipient.clone(), amount_received_ld: expected_amount_ld },

package/contracts/oapps/oft-core/src/tests/test_msg_inspector.rs

@@ -0,0 +1,323 @@
+//! 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::interfaces::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) {
+        // Do nothing - inspection passes
+    }
+}
+
+#[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) {
+        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 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()),).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    setup.oft.set_msg_inspector(&Some(inspector_address.clone()));
+
+    // 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()),).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    setup.oft.set_msg_inspector(&Some(inspector_address));
+
+    // 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>,).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    setup.oft.set_msg_inspector(&None);
+
+    // Verify inspector is removed
+    let stored_inspector = setup.oft.msg_inspector();
+    assert_eq!(stored_inspector, None);
+}
+
+// ==================== Access Control Tests ====================
+
+#[test]
+#[should_panic(expected = "HostError: Error(Auth, InvalidAction)")]
+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 tries to set the inspector (no mock_auth for owner)
+    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()),).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    // This should panic because non_owner is not the owner
+    setup.oft.set_msg_inspector(&Some(inspector_address));
+}
+
+// ==================== 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(&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()),).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    setup.oft.set_msg_inspector(&Some(inspector_address));
+
+    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(&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()),).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    setup.oft.set_msg_inspector(&Some(inspector_address));
+
+    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(&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()),).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    setup.oft.set_msg_inspector(&Some(inspector_address));
+
+    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()),).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+    setup.oft.set_msg_inspector(&Some(inspector_address));
+
+    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/contracts/oapps/oft-core/src/tests/test_send.rs

@@ -11,7 +11,7 @@ use soroban_sdk::{
     testutils::{Address as _, MockAuth, MockAuthInvoke},
     Address, Bytes, BytesN, Env, IntoVal,
 };
-use utils::testing_utils::assert_event;
+use utils::testing_utils::assert_contains_event;
 
 use super::test_utils::{create_send_param, OFTTestSetup};
 
@@ -349,7 +349,7 @@ fn test_send_emits_oft_sent_event() {
     let (msg_receipt, oft_receipt) = setup.send(&sender, &send_param, &fee, &sender, &quoted_receipt);
 
     // Assert OFTSent event was emitted with correct values
-    assert_event(
+    assert_contains_event(
         &env,
         &setup.oft.address,
         OFTSent {

package/contracts/oapps/oft-core/src/tests/test_utils.rs

@@ -16,8 +16,6 @@ use soroban_sdk::{
     token::{StellarAssetClient, TokenClient},
     Address, Bytes, BytesN, Env, IntoVal, String, Symbol,
 };
-use stellar_macros::default_impl;
-use stellar_tokens::fungible::{Base, FungibleToken};
 
 // ==================== Constants ====================
 
@@ -106,7 +104,7 @@ pub fn create_origin(src_eid: u32, sender: &BytesN<32>, nonce: u64) -> Origin {
 mod test_mint_burn_oft {
     use crate::{
         self as oft_core,
-        oft_core::{initialize_oft, lz_receive, OFTCore, OFTInternal},
+        oft_core::{OFTCore, OFTInternal},
         types::OFTReceipt,
     };
     use endpoint_v2::Origin;
@@ -133,7 +131,7 @@ mod test_mint_burn_oft {
             delegate: &Option<Address>,
             shared_decimals: u32,
         ) {
-            initialize_oft::<Self>(env, owner, token, endpoint, delegate, shared_decimals)
+            Self::__initialize_oft(env, owner, token, endpoint, delegate, shared_decimals)
         }
     }
 
@@ -150,7 +148,7 @@ mod test_mint_burn_oft {
             executor: &Address,
             value: i128,
         ) {
-            lz_receive::<Self>(env, executor, origin, guid, message, extra_data, value)
+            <Self as OFTInternal>::__receive(env, origin, guid, message, extra_data, executor, value)
         }
     }
 
@@ -174,7 +172,7 @@ pub use test_mint_burn_oft::TestMintBurnOFT;
 mod test_lock_unlock_oft {
     use crate::{
         self as oft_core,
-        oft_core::{initialize_oft, lz_receive, OFTCore, OFTInternal},
+        oft_core::{OFTCore, OFTInternal},
         types::OFTReceipt,
     };
     use endpoint_v2::Origin;
@@ -194,7 +192,7 @@ mod test_lock_unlock_oft {
             delegate: &Option<Address>,
             shared_decimals: u32,
         ) {
-            initialize_oft::<Self>(env, owner, token, endpoint, delegate, shared_decimals)
+            Self::__initialize_oft(env, owner, token, endpoint, delegate, shared_decimals)
         }
     }
 
@@ -211,7 +209,7 @@ mod test_lock_unlock_oft {
             executor: &Address,
             value: i128,
         ) {
-            lz_receive::<Self>(env, executor, origin, guid, message, extra_data, value)
+            <Self as OFTInternal>::__receive(env, origin, guid, message, extra_data, executor, value)
         }
     }
 
@@ -251,6 +249,7 @@ impl DummyRecipient {
     pub fn __constructor(_env: &Env) {}
 }
 
+/// Simple token contract for testing (replaces OpenZeppelin dependency)
 #[contract]
 pub struct DummyToken;
 
@@ -260,9 +259,19 @@ impl DummyToken {
         env.storage().instance().get(&symbol_short!("admin")).unwrap()
     }
 
+    fn get_balance(env: &Env, addr: &Address) -> i128 {
+        env.storage().persistent().get(&addr).unwrap_or(0)
+    }
+
+    fn set_balance(env: &Env, addr: &Address, amount: i128) {
+        env.storage().persistent().set(&addr, &amount);
+    }
+
     pub fn __constructor(env: &Env, owner: Address, decimals: u32) {
-        Base::set_metadata(env, decimals, String::from_str(env, "DummyToken"), String::from_str(env, "DUMMY"));
         env.storage().instance().set(&symbol_short!("admin"), &owner);
+        env.storage().instance().set(&symbol_short!("decimal"), &decimals);
+        env.storage().instance().set(&symbol_short!("name"), &String::from_str(env, "DummyToken"));
+        env.storage().instance().set(&symbol_short!("symbol"), &String::from_str(env, "DUMMY"));
     }
 
     // keep the same behavior as SAC that requires admin's authorization
@@ -273,21 +282,57 @@ impl DummyToken {
 
     pub fn mint(env: &Env, to: &Address, amount: i128) {
         Self::admin(env).require_auth();
-        Base::mint(env, &to, amount);
+        if amount < 0 {
+            panic!("negative amount");
+        }
+        let balance = Self::get_balance(env, to);
+        Self::set_balance(env, to, balance + amount);
         log!(&env, "minted {} to {}", amount, to);
     }
 
     // keep the same behavior as SAC that requires from's authorization
     pub fn burn(env: &Env, from: &Address, amount: i128) {
-        Base::burn(env, &from, amount);
+        from.require_auth();
+        if amount < 0 {
+            panic!("negative amount");
+        }
+        let balance = Self::get_balance(env, from);
+        if balance < amount {
+            panic!("insufficient balance");
+        }
+        Self::set_balance(env, from, balance - amount);
         log!(&env, "burned {} from {}", amount, from);
     }
-}
 
-#[default_impl]
-#[contractimpl]
-impl FungibleToken for DummyToken {
-    type ContractType = Base;
+    pub fn balance(env: &Env, id: Address) -> i128 {
+        Self::get_balance(env, &id)
+    }
+
+    pub fn transfer(env: &Env, from: Address, to: Address, amount: i128) {
+        from.require_auth();
+        if amount < 0 {
+            panic!("negative amount");
+        }
+        let from_balance = Self::get_balance(env, &from);
+        if from_balance < amount {
+            panic!("insufficient balance");
+        }
+        Self::set_balance(env, &from, from_balance - amount);
+        let to_balance = Self::get_balance(env, &to);
+        Self::set_balance(env, &to, to_balance + amount);
+    }
+
+    pub fn decimals(env: &Env) -> u32 {
+        env.storage().instance().get(&symbol_short!("decimal")).unwrap_or(7)
+    }
+
+    pub fn name(env: &Env) -> String {
+        env.storage().instance().get(&symbol_short!("name")).unwrap()
+    }
+
+    pub fn symbol(env: &Env) -> String {
+        env.storage().instance().get(&symbol_short!("symbol")).unwrap()
+    }
 }
 
 // ==================== Mock Endpoint ====================