@layerzerolabs/omni-counter-stellar-contracts 0.2.122

package/Cargo.toml

@@ -0,0 +1,52 @@
+[package]
+name = "counter"
+version = "0.0.1"
+edition = "2021"
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+doctest = false
+
+[dependencies]
+soroban-sdk = { version = "25.1.1", features = ["hazmat-address", "hazmat-crypto"] }
+endpoint-v2 = { path = "dependencies/protocol-stellar-v2/endpoint-v2", default-features = false, features = ["library"] }
+utils = { path = "dependencies/common-utils-stellar-contracts" }
+common-macros = { path = "dependencies/common-utils-macros-stellar-contracts" }
+oapp = { path = "dependencies/oapp-stellar-contracts" }
+oapp-macros = { path = "dependencies/oapp-macros-stellar-contracts" }
+
+[profile.release]
+opt-level = "z"
+overflow-checks = true
+debug = 0
+strip = "symbols"
+debug-assertions = false
+panic = "abort"
+codegen-units = 1
+lto = true
+
+[profile.release-with-logs]
+inherits = "release"
+debug-assertions = true
+
+[dev-dependencies]
+soroban-sdk = { version = "25.1.1", features = ["hazmat-address", "hazmat-crypto", "testutils"] }
+utils = { path = "dependencies/common-utils-stellar-contracts", features = ["testutils"] }
+simple-message-lib = { path = "dependencies/protocol-stellar-v2/message-libs/simple-message-lib", features = ["testutils"] }
+blocked-message-lib = { path = "dependencies/protocol-stellar-v2/message-libs/blocked-message-lib" }
+message-lib-common = { path = "dependencies/protocol-stellar-v2/message-libs/message-lib-common", features = ["testutils"] }
+endpoint-v2 = { path = "dependencies/protocol-stellar-v2/endpoint-v2", features = ["testutils"] }
+executor = { path = "dependencies/protocol-stellar-v2/workers/executor", features = ["testutils"] }
+uln302 = { path = "dependencies/protocol-stellar-v2/message-libs/uln-302", features = ["testutils"] }
+dvn = { path = "dependencies/protocol-stellar-v2/workers/dvn", features = ["testutils"] }
+dvn-fee-lib = { path = "dependencies/protocol-stellar-v2/workers/dvn-fee-lib", features = ["testutils"] }
+executor-fee-lib = { path = "dependencies/protocol-stellar-v2/workers/executor-fee-lib", features = ["testutils"] }
+treasury = { path = "dependencies/protocol-stellar-v2/message-libs/treasury", features = ["testutils"] }
+price-feed = { path = "dependencies/protocol-stellar-v2/workers/price-feed", features = ["testutils"] }
+fee-lib-interfaces = { path = "dependencies/protocol-stellar-v2/workers/fee-lib-interfaces" }
+executor-helper = { path = "dependencies/protocol-stellar-v2/workers/executor-helper" }
+k256 = "0.13"
+sha3 = "0.10"
+rand = "0.8"
+ed25519-dalek = "2"

package/LICENSE

@@ -0,0 +1,23 @@
+Copyright (c) 2026 - LayerZero Labs Ltd.
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.

package/clippy.toml

@@ -0,0 +1,6 @@
+# Clippy configuration for Stellar contracts
+
+# Set the too_many_arguments threshold to 11.
+# This aligns with Stellar: contract functions are limited to 10 parameters, plus 1 for 'env'.
+# (Default is 7; raised here to prevent unnecessary clippy warnings on valid contract interfaces.)
+too-many-arguments-threshold = 11

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@layerzerolabs/omni-counter-stellar-contracts",
+  "version": "0.2.122",
+  "private": false,
+  "license": "MIT",
+  "files": [
+    "src",
+    "Cargo.toml",
+    "rust-toolchain.toml",
+    "rustfmt.toml",
+    "clippy.toml"
+  ],
+  "dependencies": {
+    "@layerzerolabs/common-utils-macros-stellar-contracts": "0.2.122",
+    "@layerzerolabs/common-utils-stellar-contracts": "0.2.122",
+    "@layerzerolabs/oapp-stellar-contracts": "0.2.122",
+    "@layerzerolabs/protocol-stellar-v2": "0.2.122",
+    "@layerzerolabs/oapp-macros-stellar-contracts": "0.2.122"
+  },
+  "devDependencies": {
+    "@layerzerolabs/build-utils-rust": "0.2.122",
+    "@layerzerolabs/vm-tooling-stellar": "0.2.122"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "externalRepoConfig": {
+    "targets": [
+      "audit-external",
+      "console-pen-test",
+      "monorepo-external",
+      "onesig-client"
+    ]
+  },
+  "implicitDependencies": {
+    "@layerzerolabs/oapp-stellar-contracts": "workspace:*",
+    "@layerzerolabs/protocol-stellar-v2": "workspace:*",
+    "@layerzerolabs/common-utils-stellar-contracts": "workspace:*",
+    "@layerzerolabs/common-utils-macros-stellar-contracts": "workspace:*",
+    "@layerzerolabs/oapp-macros-stellar-contracts": "workspace:*"
+  },
+  "scripts": {
+    "build": "pnpm resolve-dependencies && pnpm exec lz-tool stellar contract build --package counter",
+    "build:native": "pnpm resolve-dependencies && pnpm exec lz-tool --docker-platform native stellar contract build --package counter",
+    "clean": "rm -rf ./dependencies ./target ./node_modules",
+    "format": "pnpm exec lz-tool --script \"cargo fmt\" stellar",
+    "lint": "pnpm resolve-dependencies && pnpm exec lz-tool --script \"cargo clippy -- -D warnings\" stellar",
+    "lint:fix": "pnpm resolve-dependencies && pnpm exec lz-tool --script \"cargo clippy --fix --allow-dirty --allow-staged && cargo fmt\" stellar",
+    "resolve-dependencies": "pnpm exec build-utils-rust resolve",
+    "test": "pnpm resolve-dependencies && pnpm exec lz-tool --script \"cargo nextest run\" stellar",
+    "test:snapshot:check": "pnpm exec turbo-snapshot check",
+    "test:snapshot:update": "pnpm exec turbo-snapshot update"
+  }
+}

package/rust-toolchain.toml

@@ -0,0 +1,4 @@
+[toolchain]
+channel = "1.90.0"
+targets = ["wasm32v1-none"]
+components = ["rustfmt", "clippy"]

package/rustfmt.toml

@@ -0,0 +1,15 @@
+format_macro_bodies = true
+max_width = 120
+format_macro_matchers = true
+format_strings = true
+imports_granularity = "Crate"
+match_arm_blocks = false
+reorder_impl_items = true
+group_imports = "StdExternalCrate"
+use_field_init_shorthand = true
+use_small_heuristics = "Max"
+wrap_comments = true
+format_code_in_doc_comments = true
+
+# most of these are unstable, so we enable them
+unstable_features = true

package/src/codec.rs

@@ -0,0 +1,62 @@
+use soroban_sdk::{Bytes, Env, U256};
+use utils::option_ext::OptionExt;
+
+use crate::{errors::CounterError, u256_ext::U256Ext};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u8)]
+pub enum MsgType {
+    Vanilla = 1,
+    Composed = 2,
+    #[allow(clippy::upper_case_acronyms)]
+    ABA = 3,
+    ComposedABA = 4,
+}
+
+impl From<u8> for MsgType {
+    fn from(value: u8) -> Self {
+        match value {
+            1 => MsgType::Vanilla,
+            2 => MsgType::Composed,
+            3 => MsgType::ABA,
+            4 => MsgType::ComposedABA,
+            _ => panic!("invalid msg type"),
+        }
+    }
+}
+
+pub const _MSG_TYPE_OFFSET: u8 = 0;
+pub const SRC_EID_OFFSET: u8 = 1;
+pub const VALUE_OFFSET: u8 = 5;
+
+pub fn encode(env: &Env, msg_type: MsgType, src_eid: u32) -> Bytes {
+    let msg_type: u8 = msg_type as u8;
+
+    let mut data = Bytes::new(env);
+    data.extend_from_array(&msg_type.to_be_bytes());
+    data.extend_from_array(&src_eid.to_be_bytes());
+
+    data
+}
+
+pub fn encode_with_value(env: &Env, msg_type: MsgType, src_eid: u32, value: u32) -> Bytes {
+    let mut data = encode(env, msg_type, src_eid);
+    data.append(&U256::from_u32(env, value).to_be_bytes());
+    data
+}
+
+pub fn msg_type(data: &Bytes) -> MsgType {
+    data.get(0).unwrap_or_else(|| panic!("cannot get msg type")).into()
+}
+
+pub fn src_eid(data: &Bytes) -> u32 {
+    let mut src_eid_bytes = [0u8; 4];
+    data.slice((SRC_EID_OFFSET as u32)..(VALUE_OFFSET as u32)).copy_into_slice(&mut src_eid_bytes);
+    u32::from_be_bytes(src_eid_bytes)
+}
+
+pub fn value(env: &Env, data: &Bytes) -> i128 {
+    let slice = data.slice((VALUE_OFFSET as u32)..data.len());
+    let value = if slice.is_empty() { U256::from_u32(env, 0) } else { U256::from_be_bytes(env, &slice) };
+    value.to_i128().unwrap_or_panic(env, CounterError::InvalidMsgValue)
+}

package/src/counter.rs

@@ -0,0 +1,274 @@
+use crate::{
+    codec::{self, MsgType},
+    errors::CounterError,
+    options,
+    storage::CounterStorage,
+};
+use common_macros::{contract_impl, lz_contract, only_auth};
+use endpoint_v2::{
+    ILayerZeroComposer, LayerZeroEndpointV2Client, MessagingChannelClient, MessagingComposerClient, MessagingFee,
+    Origin,
+};
+use oapp::{
+    oapp_core::{init_ownable_oapp, OAppCore},
+    oapp_receiver::{LzReceiveInternal, OAppReceiver},
+    oapp_sender::{FeePayer, OAppSenderInternal},
+};
+use oapp_macros::oapp;
+use soroban_sdk::{assert_with_error, panic_with_error, token::TokenClient, Address, Bytes, BytesN, Env};
+
+#[lz_contract]
+#[oapp(custom = [receiver])]
+pub struct Counter;
+
+#[contract_impl]
+impl Counter {
+    pub fn __constructor(env: &Env, owner: &Address, endpoint: &Address, delegate: &Address) {
+        init_ownable_oapp::<Self>(env, owner, endpoint, delegate);
+        let endpoint_client = LayerZeroEndpointV2Client::new(env, endpoint);
+        CounterStorage::set_eid(env, &endpoint_client.eid());
+    }
+
+    pub fn quote(env: &Env, dst_eid: u32, msg_type: u32, options: &Bytes, pay_in_zro: bool) -> MessagingFee {
+        Self::__quote(env, dst_eid, &codec::encode(env, (msg_type as u8).into(), Self::eid(env)), options, pay_in_zro)
+    }
+
+    pub fn increment(env: &Env, caller: &Address, dst_eid: u32, msg_type: u32, options: &Bytes, fee: &MessagingFee) {
+        caller.require_auth();
+
+        // Increment the outbound count
+        let outbound_count = Self::outbound_count(env, dst_eid);
+        CounterStorage::set_outbound_count(env, dst_eid, &(outbound_count + 1));
+
+        // Send the message — caller already authorized via require_auth() above
+        let message = codec::encode(env, (msg_type as u8).into(), Self::eid(env));
+        Self::__lz_send(env, dst_eid, &message, options, &FeePayer::Verified(caller.clone()), fee, caller);
+    }
+
+    // ============================================================================================
+    // Owner functions
+    // ============================================================================================
+
+    #[only_auth]
+    pub fn set_ordered_nonce(env: &Env, ordered_nonce: bool) {
+        CounterStorage::set_ordered_nonce(env, &ordered_nonce);
+    }
+
+    #[only_auth]
+    pub fn skip_inbound_nonce(env: &Env, src_eid: u32, sender: &BytesN<32>, nonce: u64) {
+        let contract_address = env.current_contract_address();
+
+        let endpoint_address = Self::endpoint(env);
+        let endpoint = MessagingChannelClient::new(env, &endpoint_address);
+        endpoint.skip(&contract_address, &contract_address, &src_eid, sender, &nonce);
+
+        if CounterStorage::ordered_nonce(env) {
+            let max_received_nonce = CounterStorage::max_received_nonce(env, src_eid, sender);
+            CounterStorage::set_max_received_nonce(env, src_eid, sender, &(max_received_nonce + 1));
+        }
+    }
+
+    #[only_auth]
+    pub fn withdraw(env: &Env, to: &Address, amount: i128) {
+        let native_token = LayerZeroEndpointV2Client::new(env, &Self::endpoint(env)).native_token();
+        TokenClient::new(env, &native_token).transfer(&env.current_contract_address(), to, &amount);
+    }
+
+    // ============================================================================================
+    // View functions
+    // ============================================================================================
+
+    pub fn eid(env: &Env) -> u32 {
+        CounterStorage::eid(env).unwrap()
+    }
+
+    pub fn count(env: &Env) -> u64 {
+        CounterStorage::count(env)
+    }
+
+    pub fn composed_count(env: &Env) -> u64 {
+        CounterStorage::composed_count(env)
+    }
+
+    pub fn inbound_count(env: &Env, eid: u32) -> u64 {
+        CounterStorage::inbound_count(env, eid)
+    }
+
+    pub fn outbound_count(env: &Env, eid: u32) -> u64 {
+        CounterStorage::outbound_count(env, eid)
+    }
+
+    // ============================================================================================
+    // Internal Functions
+    // ============================================================================================
+
+    fn __accept_nonce(env: &Env, src_eid: u32, sender: &BytesN<32>, nonce: u64) {
+        let current_nonce = CounterStorage::max_received_nonce(env, src_eid, sender);
+        if CounterStorage::ordered_nonce(env) {
+            assert_with_error!(env, nonce == current_nonce + 1, CounterError::OAppInvalidNonce);
+        }
+        // Update the max nonce anyway. once the ordered mode is turned on, missing early nonces will be rejected
+        if nonce > current_nonce {
+            CounterStorage::set_max_received_nonce(env, src_eid, sender, &nonce);
+        }
+    }
+}
+
+// ============================================================================================
+// LzReceiveInternal implementation
+// ============================================================================================
+
+impl LzReceiveInternal for Counter {
+    fn __lz_receive(
+        env: &Env,
+        origin: &Origin,
+        guid: &BytesN<32>,
+        message: &Bytes,
+        _extra_data: &Bytes,
+        _executor: &Address,
+        value: i128,
+    ) {
+        // handle the message
+        Self::__accept_nonce(env, origin.src_eid, &origin.sender, origin.nonce);
+
+        let contract_address = env.current_contract_address();
+
+        // Increment the count and inbound count
+        let count = Self::count(env);
+        let inbound_count = Self::inbound_count(env, origin.src_eid);
+        CounterStorage::set_count(env, &(count + 1));
+        CounterStorage::set_inbound_count(env, origin.src_eid, &(inbound_count + 1));
+
+        let assert_received_value = || {
+            let expected_msg_value = codec::value(env, message);
+            assert_with_error!(env, value >= expected_msg_value, CounterError::InsufficientValue);
+        };
+
+        match codec::msg_type(message) {
+            MsgType::Vanilla => {
+                assert_received_value();
+            }
+            MsgType::Composed | MsgType::ComposedABA => {
+                let endpoint: MessagingComposerClient<'_> = MessagingComposerClient::new(env, &Self::endpoint(env));
+                endpoint.send_compose(&contract_address, &contract_address, guid, &0, message);
+            }
+            MsgType::ABA => {
+                assert_received_value();
+
+                // Increment the outbound count
+                let outbound_count = Self::outbound_count(env, origin.src_eid);
+                CounterStorage::set_outbound_count(env, origin.src_eid, &(outbound_count + 1));
+
+                // Send the response message — contract is the fee payer (auto-authorized)
+                let options = options::executor_lz_receive_option(env, 200000, 10);
+                Self::__lz_send(
+                    env,
+                    origin.src_eid,
+                    &codec::encode_with_value(env, MsgType::Vanilla, Self::eid(env), 10),
+                    &options,
+                    &FeePayer::Verified(contract_address.clone()),
+                    &MessagingFee { native_fee: value, zro_fee: 0 },
+                    &contract_address,
+                );
+            }
+        }
+    }
+}
+
+// ============================================================================================
+// Custom OAppReceiver implementation
+// ============================================================================================
+
+#[contract_impl(contracttrait)]
+impl OAppReceiver for Counter {
+    fn next_nonce(env: &Env, src_eid: u32, sender: &BytesN<32>) -> u64 {
+        if CounterStorage::ordered_nonce(env) {
+            CounterStorage::max_received_nonce(env, src_eid, sender) + 1
+        } else {
+            0
+        }
+    }
+}
+
+// ============================================================================================
+// ILayerZeroComposer implementation
+// ============================================================================================
+
+#[contract_impl]
+impl ILayerZeroComposer for Counter {
+    fn lz_compose(
+        env: &Env,
+        executor: &Address,
+        from: &Address,
+        guid: &BytesN<32>,
+        index: u32,
+        message: &Bytes,
+        _extra_data: &Bytes,
+        value: i128,
+    ) {
+        // Clear compose message, transfer value, and require executor auth
+        clear_compose_and_transfer::<Self>(env, executor, from, guid, index, message, value);
+
+        let msg_type = codec::msg_type(message);
+        if msg_type != MsgType::Composed && msg_type != MsgType::ComposedABA {
+            panic_with_error!(env, CounterError::InvalidMsgType);
+        }
+
+        // Assert the value is sufficient
+        let expected_msg_value = codec::value(env, message);
+        assert_with_error!(env, value >= expected_msg_value, CounterError::InsufficientValue);
+
+        // Increment the composed count
+        CounterStorage::set_composed_count(env, &(Self::composed_count(env) + 1));
+
+        // Handle ComposedABA: send response message back to source
+        if msg_type == MsgType::ComposedABA {
+            let src_eid = codec::src_eid(message);
+
+            // Increment the outbound count
+            CounterStorage::set_outbound_count(env, src_eid, &(Self::outbound_count(env, src_eid) + 1));
+
+            // Send the response message — contract is the fee payer (auto-authorized)
+            let curr_address = env.current_contract_address();
+            Self::__lz_send(
+                env,
+                src_eid,
+                &codec::encode(env, MsgType::Vanilla, Self::eid(env)),
+                &options::executor_lz_receive_option(env, 200000, 0),
+                &FeePayer::Verified(curr_address.clone()),
+                &MessagingFee { native_fee: value, zro_fee: 0 },
+                &curr_address,
+            );
+        }
+    }
+}
+
+/// Clears a compose message and transfers native token value from executor to the OApp.
+///
+/// This helper handles the common pattern in `lz_compose` implementations:
+/// 1. Requires executor authorization
+/// 2. Clears the compose message from the endpoint
+/// 3. Transfers native token from executor to OApp if value > 0
+pub fn clear_compose_and_transfer<T: OAppCore>(
+    env: &Env,
+    executor: &Address,
+    from: &Address,
+    guid: &BytesN<32>,
+    index: u32,
+    message: &Bytes,
+    value: i128,
+) {
+    executor.require_auth();
+
+    let curr_address = env.current_contract_address();
+    let endpoint = T::endpoint(env);
+
+    // Clear the compose message
+    MessagingComposerClient::new(env, &endpoint).clear_compose(&curr_address, from, guid, &index, message);
+
+    // Transfer value from executor to current contract
+    if value > 0 {
+        let native_token = LayerZeroEndpointV2Client::new(env, &endpoint).native_token();
+        TokenClient::new(env, &native_token).transfer(executor, &curr_address, &value);
+    }
+}

package/src/errors.rs

@@ -0,0 +1,9 @@
+use common_macros::contract_error;
+
+#[contract_error]
+pub enum CounterError {
+    OAppInvalidNonce,
+    InvalidMsgValue,
+    InsufficientValue,
+    InvalidMsgType,
+}

package/src/lib.rs

@@ -0,0 +1,16 @@
+#![no_std]
+
+mod codec;
+pub mod errors;
+mod options;
+mod storage;
+mod u256_ext;
+
+pub mod counter;
+
+#[cfg(test)]
+#[path = "../integration_tests/mod.rs"]
+mod integration_tests;
+
+#[cfg(test)]
+mod tests;

package/src/options.rs

@@ -0,0 +1,30 @@
+use soroban_sdk::{Bytes, Env};
+
+pub const EXECUTOR_ID: u8 = 1; // WORKER_ID
+
+pub const LZ_RECEIVE_TYPE: u8 = 1; // OPTION_TYPE
+
+// copied from solana's counter options.rs
+pub fn executor_lz_receive_option(env: &Env, gas_limit: u128, value: u128) -> Bytes {
+    let mut options = Bytes::new(env);
+
+    options.extend_from_slice(&3u16.to_be_bytes());
+
+    options.push_back(EXECUTOR_ID);
+
+    let gas_limit_bytes = gas_limit.to_be_bytes();
+    let value_bytes = value.to_be_bytes();
+
+    if value == 0 {
+        options.extend_from_slice(&(gas_limit_bytes.len() as u16 + 1).to_be_bytes());
+        options.push_back(LZ_RECEIVE_TYPE);
+        options.extend_from_slice(&gas_limit_bytes);
+    } else {
+        options.extend_from_slice(&((gas_limit_bytes.len() + value_bytes.len()) as u16 + 1).to_be_bytes());
+        options.push_back(LZ_RECEIVE_TYPE);
+        options.extend_from_slice(&gas_limit_bytes);
+        options.extend_from_slice(&value_bytes);
+    }
+
+    options
+}

package/src/storage.rs

@@ -0,0 +1,32 @@
+use common_macros::storage;
+use soroban_sdk::BytesN;
+
+#[storage]
+pub enum CounterStorage {
+    #[instance(u32)]
+    EID,
+
+    #[persistent(u64)]
+    #[default(0)]
+    MaxReceivedNonce { eid: u32, sender: BytesN<32> }, // (eid, sender) => nonce
+
+    #[instance(bool)]
+    #[default(false)]
+    OrderedNonce,
+
+    #[instance(u64)]
+    #[default(0)]
+    Count,
+
+    #[instance(u64)]
+    #[default(0)]
+    ComposedCount,
+
+    #[persistent(u64)]
+    #[default(0)]
+    InboundCount { eid: u32 },
+
+    #[persistent(u64)]
+    #[default(0)]
+    OutboundCount { eid: u32 },
+}

package/src/tests/mod.rs

@@ -0,0 +1,24 @@
+use soroban_sdk::{
+    testutils::{MockAuth, MockAuthInvoke},
+    token::StellarAssetClient,
+    Address, Env, IntoVal,
+};
+
+pub mod test_codec;
+pub mod test_counter;
+pub mod test_u256_ext;
+
+pub fn mint_to(env: &Env, owner: &Address, native_token: &Address, to: &Address, amount: i128) {
+    env.mock_auths(&[MockAuth {
+        address: owner,
+        invoke: &MockAuthInvoke {
+            contract: native_token,
+            fn_name: "mint",
+            args: (to, amount).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    let sac = StellarAssetClient::new(env, native_token);
+    sac.mint(to, &amount);
+}

package/src/tests/test_codec.rs

@@ -0,0 +1,64 @@
+use crate::codec::*;
+use soroban_sdk::{Bytes, Env};
+
+#[test]
+fn test_encode_and_decode() {
+    let env = Env::default();
+    let _msg_type = 1;
+    let _src_eid = 1;
+    let data = encode(&env, _msg_type.into(), _src_eid);
+    assert_eq!(msg_type(&data), MsgType::from(_msg_type));
+    assert_eq!(src_eid(&data), _src_eid);
+}
+
+#[test]
+fn test_encode_and_decode_with_value() {
+    let env = Env::default();
+    let _msg_type = 1;
+    let _src_eid = 1;
+    let _value = 100u32;
+    let data = encode_with_value(&env, _msg_type.into(), _src_eid, _value);
+    assert_eq!(msg_type(&data), MsgType::from(_msg_type));
+    assert_eq!(src_eid(&data), _src_eid);
+    assert_eq!(value(&env, &data), _value as i128);
+}
+
+#[test]
+fn test_msg_type() {
+    let env = Env::default();
+    let _msg_type = 1;
+    let data = encode(&env, _msg_type.into(), 1);
+    assert_eq!(msg_type(&data), MsgType::from(_msg_type));
+}
+
+#[test]
+fn test_zero_value_when_not_provided() {
+    let env = Env::default();
+    let data = encode(&env, 1.into(), 1);
+    assert_eq!(value(&env, &data), 0i128);
+}
+
+#[test]
+#[should_panic(expected = "cannot get msg type")]
+fn test_msg_type_panic_on_invalid_data() {
+    let env = Env::default();
+    let data = Bytes::new(&env);
+    msg_type(&data);
+}
+
+#[test]
+#[should_panic(expected = "object index out of bounds")]
+fn test_src_eid_panic_on_invalid_data() {
+    let env = Env::default();
+    let data = Bytes::new(&env);
+    src_eid(&data);
+}
+
+#[test]
+#[should_panic(expected = "expected fixed-length bytes slice, got slice with different size")]
+fn test_value_panic_on_short_value() {
+    let env = Env::default();
+    let mut data = encode(&env, 1.into(), 1);
+    data.extend_from_array(&[0u8; 3]);
+    value(&env, &data);
+}

package/src/tests/test_counter.rs

@@ -0,0 +1,387 @@
+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,
+};
+
+use crate::{
+    codec::{self, MsgType},
+    counter::{Counter, CounterClient},
+    errors::CounterError,
+    tests::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]);
+    let peer_option = Some(peer.clone());
+    env.mock_auths(&[MockAuth {
+        address: owner,
+        invoke: &MockAuthInvoke {
+            contract: &counter.address,
+            fn_name: "set_peer",
+            args: (&dst_eid, &peer_option, owner).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    counter.set_peer(&dst_eid, &peer_option, owner);
+    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, 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);
+
+    let sub_invokes_with_transfer = MockAuthInvoke {
+        contract: &native_token,
+        fn_name: "transfer",
+        args: (&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, 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, 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);
+
+    let sub_invokes_with_transfer = MockAuthInvoke {
+        contract: &native_token,
+        fn_name: "transfer",
+        args: (&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, value);
+    let executor = Address::generate(&env);
+    let extra_data = Bytes::new(&env);
+
+    mint_to(&env, &owner, &native_token, &executor, value as i128);
+    let sub_invokes_with_transfer = MockAuthInvoke {
+        contract: &native_token,
+        fn_name: "transfer",
+        args: (&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, 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, 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);
+    let sub_invokes_with_transfer = MockAuthInvoke {
+        contract: &native_token,
+        fn_name: "transfer",
+        args: (&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/src/tests/test_u256_ext.rs

@@ -0,0 +1,48 @@
+use crate::u256_ext::U256Ext;
+use soroban_sdk::{Env, U256};
+
+#[test]
+fn test_to_i128_with_small_value() {
+    let env = Env::default();
+    let val = U256::from_u128(&env, 100);
+    assert_eq!(val.to_i128(), Some(100i128));
+}
+
+#[test]
+fn test_to_i128_with_zero() {
+    let env = Env::default();
+    let val = U256::from_u128(&env, 0);
+    assert_eq!(val.to_i128(), Some(0i128));
+}
+
+#[test]
+fn test_to_i128_with_i128_max() {
+    let env = Env::default();
+    let val = U256::from_u128(&env, i128::MAX as u128);
+    assert_eq!(val.to_i128(), Some(i128::MAX));
+}
+
+#[test]
+fn test_to_i128_with_value_larger_than_i128_max_returns_none() {
+    let env = Env::default();
+    // i128::MAX + 1 should not fit in i128
+    let val = U256::from_u128(&env, (i128::MAX as u128) + 1);
+    assert_eq!(val.to_i128(), None);
+}
+
+#[test]
+fn test_to_i128_with_u128_max_returns_none() {
+    let env = Env::default();
+    let val = U256::from_u128(&env, u128::MAX);
+    assert_eq!(val.to_i128(), None);
+}
+
+#[test]
+fn test_to_i128_with_high_bits_set_returns_none() {
+    let env = Env::default();
+    // Create a U256 with high 128 bits set (value > u128::MAX)
+    // from_parts takes (hi_hi, hi_lo, lo_hi, lo_lo) where each is u64
+    // Setting hi_hi or hi_lo to non-zero makes it > u128::MAX
+    let val = U256::from_parts(&env, 1, 0, 0, 0); // Sets bits 192-255
+    assert_eq!(val.to_i128(), None);
+}

package/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
+        }
+    }
+}