@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.15

package/contracts/common-macros/src/upgradeable.rs

@@ -0,0 +1,76 @@
+use proc_macro2::TokenStream;
+use quote::quote;
+use syn::ItemStruct;
+
+/// Generates the upgradeable implementation from the `#[upgradeable]` attribute macro.
+///
+/// This function generates the implementation of the `Upgradeable` trait for a
+/// given contract type, enabling the contract to be upgraded by replacing its
+/// WASM bytecode with migration support.
+///
+/// # Behavior
+///
+/// - Implements the `upgrade` and `migrate` functions with owner-based access control.
+/// - Sets the contract crate version as `"binver"` metadata using
+///   `soroban_sdk::contractmeta!`. Gets the crate version via the env variable
+///   `CARGO_PKG_VERSION` which corresponds to the "version" attribute in
+///   Cargo.toml. If no such attribute or if it is "0.0.0", skips this step.
+/// - Requires the contract to implement `Ownable` and `UpgradeableInternal` traits.
+///
+/// # Example
+/// ```ignore
+/// #[ownable]
+/// #[upgradeable]
+/// pub struct MyContract;
+/// ```
+pub fn generate_upgradeable_impl(input: TokenStream) -> TokenStream {
+    let item_struct: ItemStruct = syn::parse2(input).unwrap_or_else(|e| panic!("failed to parse struct: {}", e));
+    let name = &item_struct.ident;
+
+    let binver = set_binver_from_env();
+
+    let upgradeable_impl = quote! {
+        use utils::upgradeable::Upgradeable as _;
+
+        #binver
+
+        // Type alias to avoid path complexity in contractimpl
+        type MigrationData = <#name as utils::upgradeable::UpgradeableInternal>::MigrationData;
+
+        /// Implement the Upgradeable trait for the contract.
+        #[common_macros::contract_impl]
+        impl utils::upgradeable::Upgradeable for #name {
+            #[common_macros::only_owner]
+            fn upgrade(env: &soroban_sdk::Env, new_wasm_hash: soroban_sdk::BytesN<32>) {
+                utils::upgradeable::upgrade(env, new_wasm_hash)
+            }
+
+            #[common_macros::only_owner]
+            fn migrate(env: &soroban_sdk::Env, migration_data: &MigrationData) {
+                utils::upgradeable::migrate::<Self>(env, migration_data)
+            }
+        }
+    };
+
+    quote! {
+        #item_struct
+        #upgradeable_impl
+    }
+}
+
+/// Sets the value of the environment variable `CARGO_PKG_VERSION` as `binver`
+/// in the wasm binary metadata. This env variable corresponds to the attribute
+/// "version" in Cargo.toml. If the attribute is missing or if it is "0.0.0",
+/// the function does nothing.
+fn set_binver_from_env() -> TokenStream {
+    // However when "version" is missing from Cargo.toml,
+    // the following does not return error, but Ok("0.0.0")
+    let version = std::env::var("CARGO_PKG_VERSION");
+
+    match version {
+        Ok(v) if v != "0.0.0" => {
+            quote! { soroban_sdk::contractmeta!(key = "binver", val = #v); }
+        }
+        _ => quote! {},
+    }
+}

package/contracts/endpoint-v2/src/endpoint_v2.rs

@@ -16,12 +16,13 @@ use crate::{
     FeeRecipient, FeesAndPacket, IMessagingComposer, LayerZeroReceiverClient, MessageLibClient, MessageLibType,
     MessagingParams, OutboundPacket, ResolvedLibrary, SendLibClient, SetConfigParam, Timeout,
 };
-use common_macros::{contract_impl, only_owner, ttl_configurable};
+use common_macros::{contract_impl, only_owner, ownable, ttl_configurable};
 use soroban_sdk::{assert_with_error, contract, token::TokenClient, vec, Address, Bytes, BytesN, Env, Vec};
 use utils::option_ext::OptionExt;
 
 #[contract]
 #[ttl_configurable]
+#[ownable]
 pub struct EndpointV2;
 
 #[contract_impl]
@@ -296,6 +297,29 @@ impl EndpointV2 {
     }
 }
 
+// ============================================================================
+// Test-only Functions
+// ============================================================================
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    impl EndpointV2 {
+        /// Test-only wrapper for build_outbound_packet to enable testing.
+        pub fn build_outbound_packet_for_test(
+            env: &Env,
+            sender: &Address,
+            dst_eid: u32,
+            receiver: &BytesN<32>,
+            message: &Bytes,
+            nonce: u64,
+        ) -> OutboundPacket {
+            Self::build_outbound_packet(env, sender, dst_eid, receiver, message, nonce)
+        }
+    }
+}
+
 // ============================================================================
 // Include Modules
 // ============================================================================

package/contracts/endpoint-v2/src/tests/endpoint_setup.rs

@@ -1,15 +1,18 @@
+use soroban_sdk::token::TokenClient;
+use soroban_sdk::{
+    testutils::{Address as _, MockAuth, MockAuthInvoke},
+    token::StellarAssetClient,
+    vec, Address, Bytes, BytesN, Env, IntoVal, Val, Vec,
+};
+
 use crate::{
     endpoint_v2::{EndpointV2, EndpointV2Client},
+    storage,
     tests::mock::{
         MockMessageLib, MockMessageLibClient, MockReceiveLib, MockReceiveLibClient, MockSendLib, MockSendLibClient,
     },
     MessageLibType,
 };
-use soroban_sdk::{
-    testutils::{Address as _, MockAuth, MockAuthInvoke},
-    token::StellarAssetClient,
-    Address, Env, IntoVal, Val, Vec,
-};
 
 pub struct TestSetup<'a> {
     pub eid: u32,
@@ -38,10 +41,10 @@ pub fn setup<'a>() -> TestSetup<'a> {
 
     // Deploy the endpoint contract
     let contract_id = env.register(EndpointV2, (&owner,));
-    let client = EndpointV2Client::new(&env, &contract_id);
-    let eid = client.eid();
+    let endpoint_client = EndpointV2Client::new(&env, &contract_id);
+    let eid = endpoint_client.eid();
 
-    TestSetup { eid, endpoint_client: client, env, owner, contract_id, native_token_client, zro_token_client }
+    TestSetup { eid, endpoint_client, env, owner, contract_id, native_token_client, zro_token_client }
 }
 
 impl<'a> TestSetup<'a> {
@@ -73,6 +76,50 @@ impl<'a> TestSetup<'a> {
         self.zro_token_client.mint(to, &amount);
     }
 
+    /// Helper function to transfer native tokens with proper authorization
+    pub fn transfer_native(&self, from: &Address, to: &Address, amount: i128) {
+        let env = &self.env;
+        let token_client = TokenClient::new(env, &self.native_token_client.address);
+        env.mock_auths(&[MockAuth {
+            address: from,
+            invoke: &MockAuthInvoke {
+                contract: &self.native_token_client.address,
+                fn_name: "transfer",
+                args: (from, to, &amount).into_val(env),
+                sub_invokes: &[],
+            },
+        }]);
+        token_client.transfer(from, to, &amount);
+    }
+
+    /// Helper function to transfer ZRO tokens with proper authorization
+    pub fn transfer_zro(&self, from: &Address, to: &Address, amount: i128) {
+        let env = &self.env;
+        let token_client = TokenClient::new(env, &self.zro_token_client.address);
+        env.mock_auths(&[MockAuth {
+            address: from,
+            invoke: &MockAuthInvoke {
+                contract: &self.zro_token_client.address,
+                fn_name: "transfer",
+                args: (from, to, &amount).into_val(env),
+                sub_invokes: &[],
+            },
+        }]);
+        token_client.transfer(from, to, &amount);
+    }
+
+    /// Helper to mint native tokens to `from` and transfer them to the endpoint contract.
+    pub fn fund_endpoint_with_native(&self, from: &Address, amount: i128) {
+        self.mint_native(from, amount);
+        self.transfer_native(from, &self.endpoint_client.address, amount);
+    }
+
+    /// Helper to mint ZRO tokens to `from` and transfer them to the endpoint contract.
+    pub fn fund_endpoint_with_zro(&self, from: &Address, amount: i128) {
+        self.mint_zro(from, amount);
+        self.transfer_zro(from, &self.endpoint_client.address, amount);
+    }
+
     // Helper to mock owner auth for common operations
     pub fn mock_owner_auth<T: IntoVal<Env, Vec<Val>>>(&self, fn_name: &str, args: T) {
         self.env.mock_auths(&[MockAuth {
@@ -128,4 +175,124 @@ impl<'a> TestSetup<'a> {
         lib_client.setup(&supported_eids);
         lib
     }
+
+    /// Helper to setup (or rotate) a default receive library for a source endpoint with a grace period.
+    /// Creates a mock receive library, registers it, and sets it as the default for the given src_eid.
+    pub fn setup_default_receive_lib(&self, src_eid: u32, grace_period: u64) -> Address {
+        let receive_lib = self.setup_mock_receive_lib(vec![&self.env, src_eid]);
+
+        self.register_library_with_auth(&receive_lib);
+        self.set_default_receive_library_with_auth(src_eid, &receive_lib, grace_period);
+
+        receive_lib
+    }
+
+    pub fn set_default_receive_library_with_auth(&self, src_eid: u32, receive_lib: &Address, grace_period: u64) {
+        self.mock_owner_auth("set_default_receive_library", (&src_eid, receive_lib, &grace_period));
+        self.endpoint_client.set_default_receive_library(&src_eid, receive_lib, &grace_period);
+    }
+
+    pub fn set_default_send_library_with_auth(&self, dst_eid: u32, send_lib: &Address) {
+        self.mock_owner_auth("set_default_send_library", (&dst_eid, send_lib));
+        self.endpoint_client.set_default_send_library(&dst_eid, send_lib);
+    }
+
+    /// Helper to setup a default send library for a destination endpoint.
+    /// Creates a mock send library, registers it, and sets it as the default for the given dst_eid.
+    pub fn setup_default_send_lib(&self, dst_eid: u32, native_fee: i128, zro_fee: i128) -> (Address, Address) {
+        let fee_recipient = Address::generate(&self.env);
+        let send_lib = self.setup_mock_send_lib(vec![&self.env, dst_eid], native_fee, zro_fee, fee_recipient.clone());
+
+        self.register_library_with_auth(&send_lib);
+
+        self.set_default_send_library_with_auth(dst_eid, &send_lib);
+
+        (send_lib, fee_recipient)
+    }
+
+    /// Helper to setup ZRO token on the endpoint
+    pub fn setup_zro_with_auth(&self) {
+        self.mock_owner_auth("set_zro", (&self.zro_token_client.address,));
+        self.endpoint_client.set_zro(&self.zro_token_client.address);
+    }
+
+    /// Helper to register a message library as the contract owner (mocks owner auth + performs call).
+    pub fn register_library_with_auth(&self, lib: &Address) {
+        self.mock_owner_auth("register_library", (lib,));
+        self.endpoint_client.register_library(lib);
+    }
+
+    /// Helper to setup a new custom receive library for an OApp with a grace period.
+    /// Returns the newly created receive library address.
+    pub fn setup_receive_library(
+        &self,
+        caller: &Address,
+        receiver: &Address,
+        src_eid: u32,
+        grace_period: u64,
+    ) -> Address {
+        let lib = self.setup_mock_receive_lib(vec![&self.env, src_eid]);
+        self.register_library_with_auth(&lib);
+        self.set_receive_library_with_auth(caller, receiver, src_eid, &Some(lib.clone()), grace_period);
+        lib
+    }
+
+    pub fn set_receive_library_with_auth(
+        &self,
+        caller: &Address,
+        receiver: &Address,
+        src_eid: u32,
+        new_lib: &Option<Address>,
+        grace_period: u64,
+    ) {
+        self.mock_auth(caller, "set_receive_library", (caller, receiver, src_eid, new_lib, grace_period));
+        self.endpoint_client.set_receive_library(caller, receiver, &src_eid, new_lib, &grace_period);
+    }
+
+    pub fn set_send_library_with_auth(
+        &self,
+        caller: &Address,
+        sender: &Address,
+        dst_eid: u32,
+        new_lib: &Option<Address>,
+    ) {
+        self.mock_auth(caller, "set_send_library", (caller, sender, dst_eid, new_lib));
+        self.endpoint_client.set_send_library(caller, sender, &dst_eid, new_lib);
+    }
+
+    pub fn set_delegate_with_auth(&self, oapp: &Address, delegate: &Option<Address>) {
+        self.mock_auth(oapp, "set_delegate", (oapp, delegate));
+        self.endpoint_client.set_delegate(oapp, delegate);
+    }
+
+    pub fn send_compose_with_auth(&self, from: &Address, to: &Address, guid: &BytesN<32>, index: u32, message: &Bytes) {
+        self.mock_auth(from, "send_compose", (from, to, guid, &index, message));
+        self.endpoint_client.send_compose(from, to, guid, &index, message);
+    }
+
+    pub fn set_lazy_inbound_nonce(&self, receiver: &Address, src_eid: u32, sender: &BytesN<32>, lazy_nonce: u64) {
+        let env = &self.env;
+        let endpoint_client = &self.endpoint_client;
+        env.as_contract(&endpoint_client.address, || {
+            storage::EndpointStorage::set_lazy_inbound_nonce(env, receiver, src_eid, sender, &lazy_nonce)
+        });
+    }
+
+    /// Helper to mark an inbound message as verified by writing its payload hash into storage.
+    ///
+    /// This is a test-only utility used by multiple messaging channel test suites.
+    pub fn inbound_as_verified(
+        &self,
+        receiver: &Address,
+        src_eid: u32,
+        sender: &BytesN<32>,
+        nonce: u64,
+        payload_hash: &BytesN<32>,
+    ) {
+        let env = &self.env;
+        let endpoint_client = &self.endpoint_client;
+        env.as_contract(&endpoint_client.address, || {
+            EndpointV2::inbound(env, receiver, src_eid, sender, nonce, payload_hash)
+        });
+    }
 }

package/contracts/endpoint-v2/src/tests/endpoint_v2/build_outbound_packet.rs

@@ -0,0 +1,76 @@
+use soroban_sdk::{testutils::Address as _, Address, Bytes, BytesN};
+
+use crate::{endpoint_v2::EndpointV2, tests::endpoint_setup::setup, util::compute_guid};
+
+#[test]
+fn test_build_outbound_packet_basic() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_addr = &context.endpoint_client.address;
+
+    let sender = Address::generate(env);
+    let dst_eid = 2u32;
+    let receiver = BytesN::from_array(env, &[1u8; 32]);
+    let message = Bytes::from_array(env, &[1, 2, 3, 4]);
+    let nonce = 1u64;
+
+    let packet = env.as_contract(endpoint_addr, || {
+        EndpointV2::build_outbound_packet_for_test(env, &sender, dst_eid, &receiver, &message, nonce)
+    });
+
+    // Verify packet fields
+    assert_eq!(packet.nonce, nonce);
+    assert_eq!(packet.src_eid, context.eid);
+    assert_eq!(packet.sender, sender);
+    assert_eq!(packet.dst_eid, dst_eid);
+    assert_eq!(packet.receiver, receiver);
+    assert_eq!(packet.message, message);
+    assert_eq!(packet.guid.len(), 32);
+
+    // Verify GUID is computed correctly
+    let expected_guid = compute_guid(env, nonce, context.eid, &sender, dst_eid, &receiver);
+    assert_eq!(packet.guid, expected_guid);
+}
+
+#[test]
+fn test_build_outbound_packet_empty_message() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_addr = &context.endpoint_client.address;
+
+    let sender = Address::generate(env);
+    let dst_eid = 2u32;
+    let receiver = BytesN::from_array(env, &[1u8; 32]);
+    let message = Bytes::new(env);
+    let nonce = 1u64;
+
+    let packet = env.as_contract(endpoint_addr, || {
+        EndpointV2::build_outbound_packet_for_test(env, &sender, dst_eid, &receiver, &message, nonce)
+    });
+
+    // Should handle empty message correctly
+    assert_eq!(packet.message.len(), 0);
+    assert_eq!(packet.nonce, nonce);
+    assert_eq!(packet.guid.len(), 32);
+}
+
+#[test]
+fn test_build_outbound_packet_large_message() {
+    let context = setup();
+    let env = &context.env;
+    let endpoint_addr = &context.endpoint_client.address;
+
+    let sender = Address::generate(env);
+    let dst_eid = 2u32;
+    let receiver = BytesN::from_array(env, &[1u8; 32]);
+    let large_message = Bytes::from_array(env, &[0u8; 1000]);
+    let nonce = 1u64;
+
+    let packet = env.as_contract(endpoint_addr, || {
+        EndpointV2::build_outbound_packet_for_test(env, &sender, dst_eid, &receiver, &large_message, nonce)
+    });
+
+    // Should handle large message correctly
+    assert_eq!(packet.message.len(), 1000);
+    assert_eq!(packet.message, large_message);
+}