@layerzerolabs/protocol-stellar-v2 0.2.8

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

@@ -0,0 +1,235 @@
+use crate::{
+    codec::{self, MsgType},
+    errors::CounterError,
+    options, storage,
+    u256_ext::U256Ext,
+};
+use common_macros::only_owner;
+use endpoint_v2::{
+    ILayerZeroComposer, ILayerZeroReceiver, LayerZeroEndpointV2Client, MessagingChannelClient, MessagingComposerClient,
+    MessagingFee, Origin,
+};
+use oapp::{oapp_core::OAppCoreOverrides, oapp_receiver::OAppReceiverOverrides};
+use oapp_macros::oapp;
+use soroban_sdk::{
+    assert_with_error, contractimpl, panic_with_error, token::TokenClient, Address, Bytes, BytesN, Env, U256,
+};
+use utils::{option_ext::OptionExt, ownable::Ownable};
+
+#[oapp]
+pub struct Counter;
+
+impl OAppReceiverOverrides for Counter {
+    fn __next_nonce(env: &Env, src_eid: u32, sender: &BytesN<32>) -> u64 {
+        if storage::CounterStorage::ordered_nonce(env) {
+            storage::CounterStorage::max_received_nonce(env, src_eid, sender) + 1
+        } else {
+            0
+        }
+    }
+
+    fn __lz_receive(
+        env: &Env,
+        executor: &Address,
+        origin: &Origin,
+        guid: &BytesN<32>,
+        message: &Bytes,
+        _extra_data: &Bytes,
+        value: i128,
+    ) {
+        let endpoint_address = Self::endpoint(env);
+        let endpoint = LayerZeroEndpointV2Client::new(env, &endpoint_address);
+        let contract_address = env.current_contract_address();
+        if value > 0 {
+            let native_token = endpoint.native_token();
+            let token_client = TokenClient::new(env, &native_token);
+            token_client.transfer_from(executor, executor, &contract_address, &value);
+        }
+
+        // handle the message
+        Self::__accept_nonce(env, origin.src_eid, &origin.sender, origin.nonce);
+        let count = Self::count(env);
+        let inbound_count = Self::inbound_count(env, origin.src_eid);
+        let outbound_count = Self::outbound_count(env, origin.src_eid);
+        match codec::msg_type(message) {
+            MsgType::Vanilla => {
+                storage::CounterStorage::set_count(env, &(count + 1));
+
+                let expected_msg_value =
+                    codec::value(env, message).to_i128().unwrap_or_panic(env, CounterError::InvalidMsgValue);
+
+                assert_with_error!(env, value >= expected_msg_value, CounterError::InsufficientValue);
+
+                storage::CounterStorage::set_inbound_count(env, origin.src_eid, &(inbound_count + 1));
+            }
+            MsgType::Composed | MsgType::ComposedABA => {
+                storage::CounterStorage::set_count(env, &(count + 1));
+                storage::CounterStorage::set_inbound_count(env, origin.src_eid, &(inbound_count + 1));
+
+                let endpoint_address = Self::endpoint(env);
+                let endpoint: MessagingComposerClient<'_> = MessagingComposerClient::new(env, &endpoint_address);
+                endpoint.send_compose(&contract_address, &contract_address, guid, &0, message);
+            }
+            MsgType::ABA => {
+                storage::CounterStorage::set_count(env, &(count + 1));
+                storage::CounterStorage::set_inbound_count(env, origin.src_eid, &(inbound_count + 1));
+                storage::CounterStorage::set_outbound_count(env, origin.src_eid, &(outbound_count + 1));
+
+                let options = options::executor_lz_receive_option(env, 200000, 10);
+                Self::__lz_send(
+                    env,
+                    &contract_address,
+                    origin.src_eid,
+                    &codec::encode_with_value(env, MsgType::Vanilla, origin.src_eid, U256::from_u32(env, 10)),
+                    &options,
+                    &MessagingFee { native_fee: value, zro_fee: 0 },
+                    &contract_address,
+                );
+            }
+        }
+    }
+}
+
+#[contractimpl]
+impl Counter {
+    pub fn __constructor(env: &Env, owner: &Address, endpoint: &Address, delegate: &Address) {
+        Self::__init_owner(env, owner);
+        Self::__oapp_initialize(env, endpoint, &Some(delegate.clone()));
+        let endpoint_client = LayerZeroEndpointV2Client::new(env, endpoint);
+        storage::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, sender: &Address, dst_eid: u32, msg_type: u32, options: &Bytes, fee: &MessagingFee) {
+        sender.require_auth();
+
+        Self::__lz_send(
+            env,
+            sender,
+            dst_eid,
+            &codec::encode(env, (msg_type as u8).into(), Self::eid(env)),
+            options,
+            fee,
+            sender,
+        );
+        let outbound_count = Self::outbound_count(env, dst_eid);
+        storage::CounterStorage::set_outbound_count(env, dst_eid, &(outbound_count + 1));
+    }
+
+    // === Owner functions ===
+
+    #[only_owner]
+    pub fn set_ordered_nonce(env: &Env, ordered_nonce: bool) {
+        storage::CounterStorage::set_ordered_nonce(env, &ordered_nonce);
+    }
+
+    #[only_owner]
+    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 storage::CounterStorage::ordered_nonce(env) {
+            let max_received_nonce = storage::CounterStorage::max_received_nonce(env, src_eid, sender);
+            storage::CounterStorage::set_max_received_nonce(env, src_eid, sender, &(max_received_nonce + 1));
+        }
+    }
+
+    // === view functions ===
+
+    pub fn eid(env: &Env) -> u32 {
+        storage::CounterStorage::eid(env).unwrap()
+    }
+
+    pub fn count(env: &Env) -> u64 {
+        storage::CounterStorage::count(env)
+    }
+
+    pub fn composed_count(env: &Env) -> u64 {
+        storage::CounterStorage::composed_count(env)
+    }
+
+    pub fn inbound_count(env: &Env, eid: u32) -> u64 {
+        storage::CounterStorage::inbound_count(env, eid)
+    }
+
+    pub fn outbound_count(env: &Env, eid: u32) -> u64 {
+        storage::CounterStorage::outbound_count(env, eid)
+    }
+
+    // === Internal functions ===
+
+    fn __accept_nonce(env: &Env, src_eid: u32, sender: &BytesN<32>, nonce: u64) {
+        let current_nonce = storage::CounterStorage::max_received_nonce(env, src_eid, sender);
+        if storage::CounterStorage::ordered_nonce(env) {
+            assert_with_error!(env, nonce == current_nonce + 1, CounterError::OAppInvalidNonce);
+        }
+
+        if nonce > current_nonce {
+            storage::CounterStorage::set_max_received_nonce(env, src_eid, sender, &nonce);
+        }
+    }
+}
+
+#[contractimpl]
+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,
+    ) {
+        executor.require_auth();
+        let contract_address = env.current_contract_address();
+        let endpoint_address = Self::endpoint(env);
+
+        // Transfer value from executor to contract for lz_send
+        if value > 0 {
+            let endpoint = LayerZeroEndpointV2Client::new(env, &endpoint_address);
+            let native_token = endpoint.native_token();
+            let token_client = TokenClient::new(env, &native_token);
+            token_client.transfer_from(executor, executor, &contract_address, &value);
+        }
+
+        let endpoint = MessagingComposerClient::new(env, &endpoint_address);
+        // try clear the compose first
+        endpoint.clear_compose(&contract_address, from, guid, &index, message);
+
+        // handle the message
+        let composed_count = Self::composed_count(env);
+
+        match codec::msg_type(message) {
+            MsgType::Composed => {
+                storage::CounterStorage::set_composed_count(env, &(composed_count + 1));
+            }
+            MsgType::ComposedABA => {
+                storage::CounterStorage::set_composed_count(env, &(composed_count + 1));
+
+                let src_eid = codec::src_eid(message);
+                let outbound_count = Self::outbound_count(env, src_eid);
+                storage::CounterStorage::set_outbound_count(env, src_eid, &(outbound_count + 1));
+
+                let options = options::executor_lz_receive_option(env, 200000, 0);
+                Self::__lz_send(
+                    env,
+                    &contract_address,
+                    src_eid,
+                    &codec::encode(env, MsgType::Vanilla, Self::eid(env)),
+                    &options,
+                    &MessagingFee { native_fee: value, zro_fee: 0 },
+                    &contract_address,
+                );
+            }
+            _ => panic_with_error!(env, CounterError::InvalidMsgType),
+        }
+    }
+}

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

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

package/contracts/oapps/counter/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/contracts/oapps/counter/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/contracts/oapps/counter/src/storage.rs

@@ -0,0 +1,33 @@
+use common_macros::storage;
+use soroban_sdk::BytesN;
+use utils::ttl::DefaultTtlConfigProvider;
+
+#[storage(DefaultTtlConfigProvider)]
+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/contracts/oapps/counter/src/tests/mod.rs

@@ -0,0 +1,37 @@
+use soroban_sdk::{
+    testutils::{MockAuth, MockAuthInvoke},
+    token::StellarAssetClient,
+    Address, Env, IntoVal,
+};
+
+pub mod test_codec;
+pub mod test_counter;
+
+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);
+}
+
+pub fn approve(env: &Env, from: &Address, native_token: &Address, amount: i128) {
+    env.mock_auths(&[MockAuth {
+        address: from,
+        invoke: &MockAuthInvoke {
+            contract: native_token,
+            fn_name: "approve",
+            args: (from, from, amount, 10_u32).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    let sac = StellarAssetClient::new(env, native_token);
+    sac.approve(from, from, &amount, &10_u32);
+}

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

@@ -0,0 +1,64 @@
+use crate::codec::*;
+use soroban_sdk::{Bytes, Env, U256};
+
+#[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 = U256::from_u32(&env, 100);
+    let data = encode_with_value(&env, _msg_type.into(), _src_eid, _value.clone());
+    assert_eq!(msg_type(&data), MsgType::from(_msg_type));
+    assert_eq!(src_eid(&data), _src_eid);
+    assert_eq!(_value.eq(&value(&env, &data)), true);
+}
+
+#[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), U256::from_u32(&env, 0));
+}
+
+#[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);
+}