@layerzerolabs/protocol-stellar-v2 0.2.21 → 0.2.23

package/contracts/workers/executor-helper/src/tests/setup.rs

@@ -11,12 +11,41 @@ use soroban_sdk::{
 use crate::{ComposeParams, ExecutionParams, ExecutorHelper, ExecutorHelperClient};
 
 // =============================================================================
-// Mock Endpoint (provides native_token)
+// Mock Endpoint (provides native_token and alert recording)
 // =============================================================================
 
 #[contract]
 pub struct MockEndpoint;
 
+#[contracttype]
+#[derive(Clone, Debug)]
+pub struct LzReceiveAlertRecord {
+    pub executor: Address,
+    pub origin: Origin,
+    pub receiver: Address,
+    pub guid: BytesN<32>,
+    pub gas_limit: i128,
+    pub value: i128,
+    pub message: Bytes,
+    pub extra_data: Bytes,
+    pub reason: Bytes,
+}
+
+#[contracttype]
+#[derive(Clone, Debug)]
+pub struct LzComposeAlertRecord {
+    pub executor: Address,
+    pub from: Address,
+    pub to: Address,
+    pub guid: BytesN<32>,
+    pub index: u32,
+    pub gas_limit: i128,
+    pub value: i128,
+    pub message: Bytes,
+    pub extra_data: Bytes,
+    pub reason: Bytes,
+}
+
 #[contractimpl]
 impl MockEndpoint {
     pub fn __constructor(env: &Env, native_token: &Address) {
@@ -26,6 +55,70 @@ impl MockEndpoint {
     pub fn native_token(env: &Env) -> Address {
         env.storage().instance().get(&Symbol::new(env, "native_token")).unwrap()
     }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn lz_receive_alert(
+        env: &Env,
+        executor: &Address,
+        origin: &Origin,
+        receiver: &Address,
+        guid: &BytesN<32>,
+        gas_limit: i128,
+        value: i128,
+        message: &Bytes,
+        extra_data: &Bytes,
+        reason: &Bytes,
+    ) {
+        let record = LzReceiveAlertRecord {
+            executor: executor.clone(),
+            origin: origin.clone(),
+            receiver: receiver.clone(),
+            guid: guid.clone(),
+            gas_limit,
+            value,
+            message: message.clone(),
+            extra_data: extra_data.clone(),
+            reason: reason.clone(),
+        };
+        env.storage().instance().set(&Symbol::new(env, "lz_receive_alert"), &record);
+    }
+
+    pub fn get_lz_receive_alert(env: &Env) -> Option<LzReceiveAlertRecord> {
+        env.storage().instance().get(&Symbol::new(env, "lz_receive_alert"))
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    pub fn lz_compose_alert(
+        env: &Env,
+        executor: &Address,
+        from: &Address,
+        to: &Address,
+        guid: &BytesN<32>,
+        index: u32,
+        gas_limit: i128,
+        value: i128,
+        message: &Bytes,
+        extra_data: &Bytes,
+        reason: &Bytes,
+    ) {
+        let record = LzComposeAlertRecord {
+            executor: executor.clone(),
+            from: from.clone(),
+            to: to.clone(),
+            guid: guid.clone(),
+            index,
+            gas_limit,
+            value,
+            message: message.clone(),
+            extra_data: extra_data.clone(),
+            reason: reason.clone(),
+        };
+        env.storage().instance().set(&Symbol::new(env, "lz_compose_alert"), &record);
+    }
+
+    pub fn get_lz_compose_alert(env: &Env) -> Option<LzComposeAlertRecord> {
+        env.storage().instance().get(&Symbol::new(env, "lz_compose_alert"))
+    }
 }
 
 // =============================================================================
@@ -186,6 +279,7 @@ pub struct TestSetup<'a> {
     pub env: Env,
     pub executor_helper_client: ExecutorHelperClient<'a>,
     pub executor: Address,
+    pub endpoint: Address,
     pub receiver: Address,
     pub composer: Address,
     pub native_token: Address,
@@ -227,6 +321,7 @@ impl<'a> TestSetup<'a> {
             env,
             executor_helper_client: client,
             executor,
+            endpoint,
             receiver,
             composer,
             native_token,
@@ -363,4 +458,14 @@ impl<'a> TestSetup<'a> {
     pub fn executor_client(&self) -> MockExecutorClient<'_> {
         MockExecutorClient::new(&self.env, &self.executor)
     }
+
+    /// Returns the MockEndpointClient to access mock endpoint methods
+    pub fn endpoint_client(&self) -> MockEndpointClient<'_> {
+        MockEndpointClient::new(&self.env, &self.endpoint)
+    }
+
+    /// Mocks all authorizations including non-root - useful for simpler test cases
+    pub fn mock_all_auths(&self) {
+        self.env.mock_all_auths_allowing_non_root_auth();
+    }
 }

package/contracts/workers/worker/src/worker.rs

@@ -14,7 +14,7 @@ use utils::auth::{self, Auth};
 ///
 /// Requires the `Auth` trait to be implemented, which can be provided by either:
 /// - `#[ownable]` macro for single-owner contracts (e.g., Executor)
-/// - `Multisig` trait for multisig-controlled contracts (e.g., DVN)
+/// - `#[multisig]` macro for multisig-controlled contracts (e.g., DVN)
 #[contract_trait]
 pub trait Worker: Auth {
     // ========================================================================

package/docs/oft-guide.md

@@ -14,24 +14,24 @@ An OFT enables cross-chain token transfers through LayerZero. The framework prov
 ## Architecture
 
 ```
-┌─────────────────────────────────────────────────────────────┐
+┌──────────────────────────────────────────────────────────────┐
 │                         OFT Contract                         │
-├─────────────────────────────────────────────────────────────┤
+├─────────────────────────────────────────────────────────────-┤
 │  OFTCore (public interface)                                  │
 │  ├── quote_oft()     - Quote transfer limits and fees        │
 │  ├── quote_send()    - Quote LayerZero messaging fees        │
 │  └── send()          - Execute cross-chain transfer          │
-├─────────────────────────────────────────────────────────────┤
+├─────────────────────────────────────────────────────────────-┤
 │  OFTInternal (internal logic)                                │
 │  ├── __debit()       - Burn/lock tokens on send              │
 │  ├── __credit()      - Mint/unlock tokens on receive         │
 │  └── __receive()     - Handle incoming transfers             │
-├─────────────────────────────────────────────────────────────┤
+├─────────────────────────────────────────────────────────────-┤
 │  Extensions (optional)                                       │
 │  ├── OFTPausable     - Pause/unpause operations              │
 │  ├── OFTFee          - Collect transfer fees                 │
 │  └── RateLimiter     - Limit transfer volume                 │
-└─────────────────────────────────────────────────────────────┘
+└─────────────────────────────────────────────────────────────-┘
 ```
 
 ## Token types

package/package.json

@@ -1,23 +1,21 @@
 {
   "name": "@layerzerolabs/protocol-stellar-v2",
-  "version": "0.2.21",
+  "version": "0.2.23",
   "private": false,
   "devDependencies": {
     "@types/node": "^22.18.6",
     "tsx": "^4.19.3",
     "typescript": "^5.8.2",
-    "@layerzerolabs/common-node-utils": "0.2.21",
-    "@layerzerolabs/vm-tooling-stellar": "0.2.21"
+    "@layerzerolabs/common-node-utils": "0.2.23",
+    "@layerzerolabs/vm-tooling-stellar": "0.2.23"
   },
   "publishConfig": {
     "access": "restricted",
     "registry": "https://registry.npmjs.org/"
   },
   "scripts": {
-    "build": "pnpm build:contracts:sandbox && pnpm generate:sdk",
-    "build:contracts:mainnet": "pnpm exec lz-tool stellar contract build --features mainnet",
-    "build:contracts:sandbox": "pnpm exec lz-tool stellar contract build --features sandbox",
-    "build:contracts:testnet": "pnpm exec lz-tool stellar contract build --features testnet",
+    "build": "pnpm build:contracts && pnpm generate:sdk",
+    "build:contracts": "pnpm exec lz-tool stellar contract build",
     "format": "pnpm exec lz-tool --script \"cargo fmt\" stellar",
     "generate:sdk": "pnpm exec lz-tool --script \"cargo run -p ts-bindings-gen\" stellar",
     "lint": "pnpm exec lz-tool --script \"cargo clippy -- -D warnings\" stellar",