@layerzerolabs/protocol-stellar-v2 0.2.8

package/contracts/oapps/counter/src/tests/test_counter.rs

@@ -0,0 +1,390 @@
+extern crate std;
+
+use endpoint_v2::{MessagingFee, MessagingParams, MessagingReceipt, Origin};
+use soroban_sdk::{
+    contract, contractimpl, log, symbol_short,
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    Address, Bytes, BytesN, Env, IntoVal, U256,
+};
+
+use crate::{
+    codec::{self, MsgType},
+    counter::{Counter, CounterClient},
+    errors::CounterError,
+    tests::{approve, mint_to},
+};
+
+struct TestSetup<'a> {
+    env: Env,
+    owner: Address,
+    counter: CounterClient<'a>,
+    endpoint: Address,
+    native_token: Address,
+}
+
+#[contract]
+pub struct DummyEndpoint;
+
+#[contractimpl]
+impl DummyEndpoint {
+    pub fn __constructor(env: Env, native_token: Address) {
+        env.storage().instance().set(&symbol_short!("ntk"), &native_token);
+    }
+
+    pub fn set_delegate(_env: Env, _oapp: Address, _delegate: Address) {
+        // do nothing
+    }
+
+    pub fn eid(_env: Env) -> u32 {
+        100
+    }
+
+    pub fn native_token(env: Env) -> Address {
+        env.storage().instance().get(&symbol_short!("ntk")).unwrap()
+    }
+
+    pub fn send(env: Env, _sender: Address, _params: MessagingParams, _refund_address: Address) -> MessagingReceipt {
+        MessagingReceipt {
+            guid: BytesN::from_array(&env, &[1u8; 32]),
+            nonce: 1,
+            fee: MessagingFee { native_fee: 100, zro_fee: 0 },
+        }
+    }
+
+    pub fn skip(_env: Env, _caller: Address, _receiver: Address, _src_eid: u32, _sender: BytesN<32>, _nonce: u64) {
+        // do nothing
+    }
+
+    pub fn clear(_env: Env, _caller: Address, _origin: Origin, _receiver: Address, _guid: BytesN<32>, _message: Bytes) {
+        // do nothing
+    }
+
+    pub fn clear_compose(
+        _env: Env,
+        _composer: Address,
+        _from: Address,
+        _guid: BytesN<32>,
+        _index: u32,
+        _message: Bytes,
+    ) {
+        // do nothing
+    }
+}
+
+fn setup<'a>() -> TestSetup<'a> {
+    let env = Env::default();
+    let owner = Address::generate(&env);
+    let sac = env.register_stellar_asset_contract_v2(owner.clone());
+
+    let endpoint = env.register(DummyEndpoint, (&sac.address(),));
+    let counter = env.register(Counter, (&owner, &endpoint, &owner));
+    let counter_client = CounterClient::new(&env, &counter);
+
+    log!(&env, "native_token: {}", sac.address());
+    log!(&env, "endpoint: {}", endpoint);
+    log!(&env, "counter: {}", counter);
+
+    TestSetup { env, owner, counter: counter_client, endpoint, native_token: sac.address() }
+}
+
+fn setup_mock_peer(env: &Env, owner: &Address, counter: &CounterClient<'_>, dst_eid: u32) -> BytesN<32> {
+    let peer = BytesN::from_array(env, &[1u8; 32]);
+    env.mock_auths(&[MockAuth {
+        address: owner,
+        invoke: &MockAuthInvoke {
+            contract: &counter.address,
+            fn_name: "set_peer",
+            args: (&dst_eid, &Some(peer.clone())).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    counter.set_peer(&dst_eid, &Some(peer.clone()));
+    peer
+}
+
+fn set_ordered_nonce(env: &Env, owner: &Address, counter: &CounterClient<'_>, ordered_nonce: bool) {
+    env.mock_auths(&[MockAuth {
+        address: owner,
+        invoke: &MockAuthInvoke {
+            contract: &counter.address,
+            fn_name: "set_ordered_nonce",
+            args: (&ordered_nonce,).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    counter.set_ordered_nonce(&ordered_nonce);
+}
+
+// tests for major entry functions
+
+#[test]
+fn test_increment() {
+    let TestSetup { env, owner, counter, endpoint, native_token, .. } = setup();
+
+    let sender = Address::generate(&env);
+    let dst_eid = 101;
+    let msg_type = MsgType::Vanilla;
+    let fee = MessagingFee { native_fee: 100, zro_fee: 0 };
+
+    setup_mock_peer(&env, &owner, &counter, dst_eid);
+    mint_to(&env, &owner, &native_token, &sender, fee.native_fee);
+
+    env.mock_auths(&[MockAuth {
+        address: &sender,
+        invoke: &MockAuthInvoke {
+            contract: &counter.address,
+            fn_name: "increment",
+            args: (&sender, &dst_eid, &(msg_type as u32), &Bytes::new(&env), &fee).into_val(&env),
+            sub_invokes: &[MockAuthInvoke {
+                contract: &native_token,
+                fn_name: "transfer",
+                args: (&sender, &endpoint, &fee.native_fee).into_val(&env),
+                sub_invokes: &[],
+            }],
+        },
+    }]);
+    counter.increment(&sender, &dst_eid, &(msg_type as u32), &Bytes::new(&env), &fee);
+
+    assert_eq!(counter.outbound_count(&dst_eid), 1);
+}
+
+#[test]
+fn test_lz_receive_vanilla() {
+    let TestSetup { env, owner, counter, native_token, .. } = setup();
+
+    let origin = Origin { src_eid: 101, sender: BytesN::from_array(&env, &[1u8; 32]), nonce: 1 };
+    let guid = BytesN::from_array(&env, &[2u8; 32]);
+    let value = 100;
+    let message = codec::encode_with_value(&env, MsgType::Vanilla, origin.src_eid, U256::from_u32(&env, value));
+    let executor = Address::generate(&env);
+    let extra_data = Bytes::new(&env);
+
+    setup_mock_peer(&env, &owner, &counter, origin.src_eid);
+
+    mint_to(&env, &owner, &native_token, &executor, value as i128);
+    approve(&env, &executor, &native_token, value as i128);
+
+    let sub_invokes_with_transfer = MockAuthInvoke {
+        contract: &native_token,
+        fn_name: "transfer_from",
+        args: (&executor, &executor, &counter.address, &(value as i128)).into_val(&env),
+        sub_invokes: &[],
+    };
+    env.mock_auths(&[MockAuth {
+        address: &executor,
+        invoke: &MockAuthInvoke {
+            contract: &counter.address,
+            fn_name: "lz_receive",
+            args: (&executor, &origin, &guid, &message, &extra_data, &(value as i128)).into_val(&env),
+            sub_invokes: &[sub_invokes_with_transfer],
+        },
+    }]);
+
+    counter.lz_receive(&executor, &origin, &guid, &message, &extra_data, &(value as i128));
+
+    assert_eq!(counter.count(), 1);
+    assert_eq!(counter.inbound_count(&origin.src_eid), 1);
+}
+
+#[test]
+#[should_panic(expected = "HostError: Error(Auth, InvalidAction)")]
+fn test_lz_receive_not_from_executor() {
+    let TestSetup { env, owner, counter, .. } = setup();
+
+    let origin = Origin { src_eid: 101, sender: BytesN::from_array(&env, &[1u8; 32]), nonce: 1 };
+    let guid = BytesN::from_array(&env, &[2u8; 32]);
+    let value = 100;
+    let message = codec::encode_with_value(&env, MsgType::Vanilla, origin.src_eid, U256::from_u32(&env, value));
+    let executor = Address::generate(&env);
+    let extra_data = Bytes::new(&env);
+
+    setup_mock_peer(&env, &owner, &counter, origin.src_eid);
+    counter.lz_receive(&executor, &origin, &guid, &message, &extra_data, &(value as i128));
+}
+
+#[test]
+fn test_lz_receive_vanilla_ordered_nonce_wrong_nonce() {
+    let TestSetup { env, owner, counter, native_token, .. } = setup();
+
+    // next nonce should be 1 instead of 999
+    let origin = Origin { src_eid: 101, sender: BytesN::from_array(&env, &[1u8; 32]), nonce: 999 };
+    let guid = BytesN::from_array(&env, &[2u8; 32]);
+    let value = 100;
+    let message = codec::encode_with_value(&env, MsgType::Vanilla, origin.src_eid, U256::from_u32(&env, value));
+    let executor = Address::generate(&env);
+    let extra_data = Bytes::new(&env);
+
+    setup_mock_peer(&env, &owner, &counter, origin.src_eid);
+    mint_to(&env, &owner, &native_token, &executor, value as i128);
+    approve(&env, &executor, &native_token, value as i128);
+
+    let sub_invokes_with_transfer = MockAuthInvoke {
+        contract: &native_token,
+        fn_name: "transfer_from",
+        args: (&executor, &executor, &counter.address, &(value as i128)).into_val(&env),
+        sub_invokes: &[],
+    };
+    set_ordered_nonce(&env, &owner, &counter, true);
+
+    env.mock_auths(&[MockAuth {
+        address: &executor,
+        invoke: &MockAuthInvoke {
+            contract: &counter.address,
+            fn_name: "lz_receive",
+            args: (&executor, &origin, &guid, &message, &extra_data, &(value as i128)).into_val(&env),
+            sub_invokes: &[sub_invokes_with_transfer],
+        },
+    }]);
+
+    let result = counter.try_lz_receive(&executor, &origin, &guid, &message, &extra_data, &(value as i128));
+    assert_eq!(result.err().unwrap().ok().unwrap(), CounterError::OAppInvalidNonce.into());
+}
+
+#[test]
+fn test_lz_compose() {
+    let TestSetup { env, owner, counter, native_token, .. } = setup();
+
+    let from = Address::generate(&env);
+    let origin = Origin { src_eid: 101, sender: BytesN::from_array(&env, &[1u8; 32]), nonce: 1 };
+    let guid = BytesN::from_array(&env, &[2u8; 32]);
+    let value = 100;
+    let message = codec::encode_with_value(&env, MsgType::Composed, origin.src_eid, U256::from_u32(&env, value));
+    let executor = Address::generate(&env);
+    let extra_data = Bytes::new(&env);
+
+    mint_to(&env, &owner, &native_token, &executor, value as i128);
+    approve(&env, &executor, &native_token, value as i128);
+    let sub_invokes_with_transfer = MockAuthInvoke {
+        contract: &native_token,
+        fn_name: "transfer_from",
+        args: (&executor, &executor, &counter.address, &(value as i128)).into_val(&env),
+        sub_invokes: &[],
+    };
+    env.mock_auths(&[MockAuth {
+        address: &executor,
+        invoke: &MockAuthInvoke {
+            contract: &counter.address,
+            fn_name: "lz_compose",
+            args: (&executor, &from, &guid, &0_u32, &message, &extra_data, &(value as i128)).into_val(&env),
+            sub_invokes: &[sub_invokes_with_transfer],
+        },
+    }]);
+
+    counter.lz_compose(&executor, &from, &guid, &0, &message, &extra_data, &(value as i128));
+
+    assert_eq!(counter.composed_count(), 1);
+}
+
+#[test]
+#[should_panic(expected = "HostError: Error(Auth, InvalidAction)")]
+fn test_lz_compose_not_from_executor() {
+    let TestSetup { env, counter, .. } = setup();
+
+    let from = Address::generate(&env);
+    let origin = Origin { src_eid: 101, sender: BytesN::from_array(&env, &[1u8; 32]), nonce: 1 };
+    let guid = BytesN::from_array(&env, &[2u8; 32]);
+    let value = 100;
+    let message = codec::encode_with_value(&env, MsgType::Composed, origin.src_eid, U256::from_u32(&env, value));
+    let executor = Address::generate(&env);
+    let extra_data = Bytes::new(&env);
+
+    counter.lz_compose(&executor, &from, &guid, &0, &message, &extra_data, &(value as i128));
+}
+
+#[test]
+fn test_lz_compose_aba() {
+    let TestSetup { env, owner, counter, native_token, .. } = setup();
+
+    let from = Address::generate(&env);
+    let origin = Origin { src_eid: 101, sender: BytesN::from_array(&env, &[1u8; 32]), nonce: 1 };
+    let guid = BytesN::from_array(&env, &[2u8; 32]);
+    let value = 100;
+    let message = codec::encode_with_value(&env, MsgType::ComposedABA, origin.src_eid, U256::from_u32(&env, value));
+    let executor = Address::generate(&env);
+    let extra_data = Bytes::new(&env);
+
+    setup_mock_peer(&env, &owner, &counter, origin.src_eid);
+    mint_to(&env, &owner, &native_token, &executor, value as i128);
+    approve(&env, &executor, &native_token, value as i128);
+    let sub_invokes_with_transfer = MockAuthInvoke {
+        contract: &native_token,
+        fn_name: "transfer_from",
+        args: (&executor, &executor, &counter.address, &(value as i128)).into_val(&env),
+        sub_invokes: &[],
+    };
+    env.mock_auths(&[MockAuth {
+        address: &executor,
+        invoke: &MockAuthInvoke {
+            contract: &counter.address,
+            fn_name: "lz_compose",
+            args: (&executor, &from, &guid, &0_u32, &message, &extra_data, &(value as i128)).into_val(&env),
+            sub_invokes: &[sub_invokes_with_transfer],
+        },
+    }]);
+
+    counter.lz_compose(&executor, &from, &guid, &0_u32, &message, &extra_data, &(value as i128));
+
+    assert_eq!(counter.composed_count(), 1);
+    assert_eq!(counter.outbound_count(&origin.src_eid), 1);
+}
+
+// tests for one step functions
+
+#[test]
+fn test_next_nonce() {
+    let TestSetup { env, owner, counter, .. } = setup();
+
+    let src_eid = 101;
+    let sender = BytesN::from_array(&env, &[1u8; 32]);
+    let nonce = counter.next_nonce(&src_eid, &sender);
+    assert_eq!(nonce, 0);
+
+    set_ordered_nonce(&env, &owner, &counter, true);
+    let nonce = counter.next_nonce(&src_eid, &sender);
+    assert_eq!(nonce, 1);
+}
+
+#[test]
+fn test_skip_inbound_nonce() {
+    let TestSetup { env, owner, counter, .. } = setup();
+
+    let src_eid = 101;
+    let sender = BytesN::from_array(&env, &[1u8; 32]);
+    let nonce = 1;
+
+    env.mock_auths(&[MockAuth {
+        address: &owner,
+        invoke: &MockAuthInvoke {
+            contract: &counter.address,
+            fn_name: "skip_inbound_nonce",
+            args: (&src_eid, &sender, &nonce).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    counter.skip_inbound_nonce(&src_eid, &sender, &nonce);
+}
+
+#[test]
+#[should_panic(expected = "HostError: Error(Auth, InvalidAction)")]
+fn test_skip_inbound_nonce_no_owner() {
+    let TestSetup { env, counter, .. } = setup();
+
+    let src_eid = 101;
+    let sender = BytesN::from_array(&env, &[1u8; 32]);
+    let nonce = 1;
+
+    let non_owner = Address::generate(&env);
+    env.mock_auths(&[MockAuth {
+        address: &non_owner,
+        invoke: &MockAuthInvoke {
+            contract: &counter.address,
+            fn_name: "skip_inbound_nonce",
+            args: (&src_eid, &sender, &nonce).into_val(&env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    counter.skip_inbound_nonce(&src_eid, &sender, &nonce);
+}

package/contracts/oapps/counter/src/u256_ext.rs

@@ -0,0 +1,21 @@
+use soroban_sdk::U256;
+
+pub trait U256Ext {
+    /// Converts U256 to i128 if the value fits.
+    /// Returns None if the value is too large to fit in an i128.
+    fn to_i128(&self) -> Option<i128>;
+}
+
+impl U256Ext for U256 {
+    fn to_i128(&self) -> Option<i128> {
+        // First try to convert to u128 (checks if high 128 bits are zero)
+        let u128_val = self.to_u128()?;
+
+        // Check if the u128 value fits within i128::MAX
+        if u128_val <= i128::MAX as u128 {
+            Some(u128_val as i128)
+        } else {
+            None
+        }
+    }
+}

package/contracts/oapps/lib.rs

@@ -0,0 +1,2 @@
+#![no_std]
+// This is an empty library crate that serves as a parent for message-lib packages

package/contracts/oapps/oapp/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "oapp"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+
+[lib]
+crate-type = ["rlib"]
+doctest = false
+
+[dependencies]
+soroban-sdk = { workspace = true }
+# workspace dependencies
+utils = { workspace = true }
+common-macros = { workspace = true }
+endpoint-v2 = { workspace = true, features = ["library"] }
+oapp-macros = { workspace = true }
+
+[dev-dependencies]
+soroban-sdk = { workspace = true, features = ["testutils"] }
+utils = { workspace = true, features = ["testutils"] }

package/contracts/oapps/oapp/src/errors.rs

@@ -0,0 +1,9 @@
+use common_macros::contract_error;
+
+#[contract_error]
+pub enum OAppError {
+    InvalidOptions = 20000,
+    NoPeer,
+    OnlyPeer,
+    ZROTokenUnavailable,
+}

package/contracts/oapps/oapp/src/lib.rs

@@ -0,0 +1,10 @@
+#![no_std]
+
+pub mod errors;
+pub mod oapp_core;
+pub mod oapp_options_type3;
+pub mod oapp_receiver;
+pub mod oapp_sender;
+
+#[cfg(test)]
+mod tests;

package/contracts/oapps/oapp/src/oapp_core.rs

@@ -0,0 +1,92 @@
+use common_macros::{event, storage};
+use endpoint_v2::LayerZeroEndpointV2Client;
+use soroban_sdk::{Address, BytesN, Env};
+use utils::{ownable::Ownable, ttl::DefaultTtlConfigProvider};
+
+pub trait OAppCore: Ownable {
+    /// Retrieves the OApp version information.
+    ///
+    /// # Returns
+    /// A tuple containing:
+    /// - `sender_version`: The version of the OAppSender implementation
+    /// - `receiver_version`: The version of the OAppReceiver implementation
+    fn oapp_version(env: &Env) -> (u64, u64);
+
+    /// Retrieves the LayerZero endpoint associated with the OApp.
+    ///
+    /// # Returns
+    /// The LayerZero endpoint client
+    fn endpoint(env: &Env) -> Address;
+
+    /// Retrieves the peer (OApp) associated with a corresponding endpoint.
+    ///
+    /// # Arguments
+    /// * `eid` - The endpoint ID
+    ///
+    /// # Returns
+    /// The peer address (OApp instance) associated with the corresponding endpoint
+    fn peer(env: &Env, eid: u32) -> Option<BytesN<32>>;
+
+    /// Sets or removes the peer address (OApp instance) for a corresponding endpoint.
+    ///
+    /// # Arguments
+    /// * `eid` - The endpoint ID
+    /// * `peer` - The address of the peer to be associated with the corresponding endpoint, or None to remove the peer
+    fn set_peer(env: &Env, eid: u32, peer: &Option<BytesN<32>>);
+
+    /// Sets the delegate address for the OApp Core.
+    ///
+    /// # Arguments
+    /// * `delegate` - The address of the delegate to be set, or None to remove the delegate
+    fn set_delegate(env: &Env, delegate: &Option<Address>);
+}
+
+// =====================================================
+// Implement overrides for the OAppCore trait
+// =====================================================
+
+#[storage(DefaultTtlConfigProvider)]
+pub enum OAppCoreStorage {
+    #[instance(Address)]
+    Endpoint,
+
+    #[persistent(BytesN<32>)]
+    Peer { eid: u32 },
+}
+
+#[event]
+pub struct PeerSet {
+    pub eid: u32,
+    pub peer: Option<BytesN<32>>,
+}
+
+pub trait OAppCoreOverrides {
+    fn __oapp_initialize(env: &Env, endpoint: &Address, delegate: &Option<Address>) {
+        OAppCoreStorage::set_endpoint(env, endpoint);
+        let endpoint_client = endpoint_v2::LayerZeroEndpointV2Client::new(env, endpoint);
+        endpoint_client.set_delegate(&env.current_contract_address(), delegate);
+    }
+
+    fn __oapp_version(_env: &Env) -> (u64, u64) {
+        (0, 0)
+    }
+
+    fn __endpoint(env: &Env) -> Address {
+        OAppCoreStorage::endpoint(env).unwrap()
+    }
+
+    fn __peer(env: &Env, eid: u32) -> Option<BytesN<32>> {
+        OAppCoreStorage::peer(env, eid)
+    }
+
+    fn __set_peer(env: &Env, eid: u32, peer: &Option<BytesN<32>>) {
+        OAppCoreStorage::set_or_remove_peer(env, eid, peer);
+        PeerSet { eid, peer: peer.clone() }.publish(env);
+    }
+
+    fn __set_delegate(env: &Env, delegate: &Option<Address>) {
+        let endpoint = Self::__endpoint(env);
+        let endpoint_client = LayerZeroEndpointV2Client::new(env, &endpoint);
+        endpoint_client.set_delegate(&env.current_contract_address(), delegate);
+    }
+}

package/contracts/oapps/oapp/src/oapp_options_type3.rs

@@ -0,0 +1,89 @@
+use crate::errors::OAppError;
+use common_macros::{event, storage};
+use soroban_sdk::{assert_with_error, contracttype, panic_with_error, Bytes, Env, Vec};
+use utils::ttl::DefaultTtlConfigProvider;
+
+// =====================================================
+// Types and Traits
+// =====================================================
+
+pub const OPTION_TYPE3: u32 = 3;
+
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct EnforcedOptionParam {
+    pub eid: u32,
+    pub msg_type: u32,
+    pub options: Bytes,
+}
+
+pub trait OAppOptionsType3 {
+    fn enforced_options(env: &Env, eid: u32, msg_type: u32) -> Bytes;
+
+    fn set_enforced_options(env: &Env, options: Vec<EnforcedOptionParam>);
+
+    fn combine_options(env: &Env, eid: u32, msg_type: u32, extra_options: &Bytes) -> Bytes;
+}
+
+// =====================================================
+// Implement overrides for the OAppOptionsType3 trait
+// =====================================================
+
+#[storage(DefaultTtlConfigProvider)]
+pub enum OAppOptionsType3Storage {
+    #[persistent(Bytes)]
+    #[default(Bytes::new(env))]
+    EnforcedOptions { eid: u32, msg_type: u32 },
+}
+
+#[event]
+pub struct EnforcedOptionSet {
+    pub enforced_option_params: Vec<EnforcedOptionParam>,
+}
+
+pub trait OAppOptionsType3Overrides {
+    fn __enforced_options(env: &Env, eid: u32, msg_type: u32) -> Bytes {
+        OAppOptionsType3Storage::enforced_options(env, eid, msg_type)
+    }
+
+    fn __set_enforced_options(env: &Env, options: Vec<EnforcedOptionParam>) {
+        for option in &options {
+            assert_option_type3(env, &option.options);
+            OAppOptionsType3Storage::set_enforced_options(env, option.eid, option.msg_type, &option.options);
+        }
+        EnforcedOptionSet { enforced_option_params: options }.publish(env);
+    }
+
+    fn __combine_options(env: &Env, eid: u32, msg_type: u32, extra_options: &Bytes) -> Bytes {
+        let mut enforced_options = Self::__enforced_options(env, eid, msg_type);
+
+        if enforced_options.is_empty() {
+            return extra_options.clone();
+        }
+
+        if extra_options.is_empty() {
+            return enforced_options;
+        }
+
+        if extra_options.len() >= 2 {
+            assert_option_type3(env, extra_options);
+
+            enforced_options.append(&extra_options.slice(2..));
+            return enforced_options;
+        }
+
+        panic_with_error!(env, OAppError::InvalidOptions);
+    }
+}
+
+// =====================================================
+// Internal Helpers
+// =====================================================
+
+pub fn assert_option_type3(env: &Env, options: &Bytes) {
+    let mut options_version_bytes = [0u8; 2];
+    options.slice(0..2).copy_into_slice(&mut options_version_bytes);
+    let options_version = u16::from_be_bytes(options_version_bytes);
+
+    assert_with_error!(env, options_version as u32 == OPTION_TYPE3, OAppError::InvalidOptions);
+}