@layerzerolabs/protocol-stellar-v2 0.2.8

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

@@ -0,0 +1,287 @@
+// TODO: split this into multiple tests files
+#[cfg(test)]
+mod tests {
+    use quote::{quote, ToTokens};
+
+    // ========================================
+    // Storage Type Attribute Tests
+    // ========================================
+
+    #[test]
+    #[should_panic(expected = "storage type must be specified exactly once")]
+    fn missing_storage_type_attribute_fails() {
+        let input: syn::ItemEnum = syn::parse_quote! {
+            enum InvalidEnum {
+                Counter,
+            }
+        };
+        crate::storage::generate_storage(quote! {}, input.to_token_stream());
+    }
+
+    #[test]
+    #[should_panic(expected = "storage type must be specified exactly once")]
+    fn multiple_storage_type_attributes_fails() {
+        let input: syn::DeriveInput = syn::parse_quote! {
+            enum InvalidEnum {
+                #[instance(u32)]
+                #[persistent(u32)]
+                Counter,
+            }
+        };
+        crate::storage::generate_storage(quote! {}, input.to_token_stream());
+    }
+
+    #[test]
+    #[should_panic(expected = "failed to parse storage variant for Counter")]
+    fn storage_type_without_type_parameter_fails() {
+        let input: syn::ItemEnum = syn::parse_quote! {
+            enum InvalidEnum {
+                #[instance]
+                Counter,
+            }
+        };
+        crate::storage::generate_storage(quote! {}, input.to_token_stream());
+    }
+
+    #[test]
+    #[should_panic(expected = "failed to parse storage variant for")]
+    fn invalid_storage_type_parameter_fails() {
+        let input: syn::ItemEnum = syn::parse_quote! {
+            enum InvalidEnum {
+                #[persistent(!@#$)]
+                Counter,
+            }
+        };
+        crate::storage::generate_storage(quote! {}, input.to_token_stream());
+    }
+
+    // ========================================
+    // Variant Type Tests
+    // ========================================
+
+    #[test]
+    #[should_panic(expected = "failed to parse enum")]
+    fn non_enum_struct_fails() {
+        let input: syn::DeriveInput = syn::parse_quote! {
+            struct NotAnEnum {
+                field: u32,
+            }
+        };
+        crate::storage::generate_storage(quote! {}.into(), input.to_token_stream().into());
+    }
+
+    #[test]
+    #[should_panic(expected = "only unit variants or named fields are supported in storage enums")]
+    fn tuple_variant_fails() {
+        let input: syn::DeriveInput = syn::parse_quote! {
+            enum InvalidEnum {
+                #[instance(u32)]
+                TupleVariant(String, u32),
+            }
+        };
+        crate::storage::generate_storage(quote! {}.into(), input.to_token_stream().into());
+    }
+
+    // ========================================
+    // Default Value Tests
+    // ========================================
+
+    #[test]
+    #[should_panic(expected = "multiple default values specified")]
+    fn multiple_default_attributes_fails() {
+        let input: syn::DeriveInput = syn::parse_quote! {
+            enum InvalidEnum {
+                #[persistent(u32)]
+                #[default(0)]
+                #[default(1)]
+                Counter,
+            }
+        };
+        crate::storage::generate_storage(quote! {}.into(), input.to_token_stream().into());
+    }
+
+    #[test]
+    #[should_panic(expected = "failed to parse default value")]
+    fn invalid_default_value_fails() {
+        let input: syn::DeriveInput = syn::parse_quote! {
+            enum InvalidEnum {
+                #[persistent(u32)]
+                #[default(!@#$%)]
+                Counter,
+            }
+        };
+        crate::storage::generate_storage(quote! {}.into(), input.to_token_stream().into());
+    }
+
+    // ========================================
+    // no_auto_ttl_extension Tests
+    // ========================================
+
+    #[test]
+    #[should_panic(expected = "no_auto_ttl_extension does not accept arguments")]
+    fn no_auto_ttl_with_arguments_fails() {
+        let input: syn::DeriveInput = syn::parse_quote! {
+            enum InvalidEnum {
+                #[persistent(u32)]
+                #[no_auto_ttl_extension(true)]
+                Counter,
+            }
+        };
+        crate::storage::generate_storage(quote! {}.into(), input.to_token_stream().into());
+    }
+
+    #[test]
+    #[should_panic(expected = "multiple no_auto_ttl_extension attributes specified")]
+    fn multiple_no_auto_ttl_attributes_fails() {
+        let input: syn::DeriveInput = syn::parse_quote! {
+            enum InvalidEnum {
+                #[persistent(u32)]
+                #[no_auto_ttl_extension]
+                #[no_auto_ttl_extension]
+                Counter,
+            }
+        };
+        crate::storage::generate_storage(quote! {}.into(), input.to_token_stream().into());
+    }
+
+    // ========================================
+    // Storage Config Tests
+    // ========================================
+
+    #[test]
+    #[should_panic(expected = "failed to parse attribute")]
+    fn invalid_ttl_provider_format_fails() {
+        let input: syn::DeriveInput = syn::parse_quote! {
+            enum TestEnum {
+                #[instance(u32)]
+                Counter,
+            }
+        };
+        crate::storage::generate_storage(quote! { unknown_option = SomeType }.into(), input.to_token_stream().into());
+    }
+
+    // ========================================
+    // Combined Attribute Tests
+    // ========================================
+
+    #[test]
+    #[should_panic(expected = "only unit variants or named fields are supported in storage enums")]
+    fn mixed_valid_and_invalid_variants_fails() {
+        let input: syn::ItemEnum = syn::parse_quote! {
+            enum InvalidEnum {
+                #[instance(u32)]
+                ValidCounter,
+                #[persistent(String)]
+                InvalidTuple(u32),
+            }
+        };
+        crate::storage::generate_storage(quote! {}, input.to_token_stream());
+    }
+
+    // ========================================
+    // Unknown Attribute Tests
+    // ========================================
+
+    #[test]
+    #[should_panic(expected = "unknown attribute")]
+    fn unknown_variant_attribute_fails() {
+        let input: syn::DeriveInput = syn::parse_quote! {
+            enum InvalidEnum {
+                #[persistent(u32)]
+                #[unknown_attr]
+                Counter,
+            }
+        };
+        crate::storage::generate_storage(quote! {}.into(), input.to_token_stream().into());
+    }
+
+    // ========================================
+    // Edge Cases
+    // ========================================
+
+    #[test]
+    #[should_panic(expected = "failed to parse storage variant for Counter")]
+    fn storage_type_with_empty_parens_fails() {
+        let input: syn::ItemEnum = syn::parse_quote! {
+            enum InvalidEnum {
+                #[instance()]
+                Counter,
+            }
+        };
+        crate::storage::generate_storage(quote! {}, input.to_token_stream());
+    }
+
+    #[test]
+    #[should_panic(expected = "failed to parse storage variant for Counter")]
+    fn storage_type_with_multiple_types_fails() {
+        let input: syn::ItemEnum = syn::parse_quote! {
+            enum InvalidEnum {
+                #[persistent(u32, String)]
+                Counter,
+            }
+        };
+        crate::storage::generate_storage(quote! {}, input.to_token_stream());
+    }
+
+    #[test]
+    fn valid_complex_enum_succeeds() {
+        let input: syn::DeriveInput = syn::parse_quote! {
+            enum ValidEnum {
+                #[instance(u32)]
+                Counter,
+                #[persistent(String)]
+                #[default("hello".to_string())]
+                Message { sender: Address },
+                #[temporary(bool)]
+                #[no_auto_ttl_extension]
+                Flag { key: String },
+            }
+        };
+
+        let result = crate::storage::generate_storage(quote! { TtlProvider }, input.to_token_stream());
+        // Should not panic - this is a valid configuration
+        assert!(!result.is_empty());
+    }
+
+    // ========================================
+    // Snapshot Tests
+    // ========================================
+    #[test]
+    fn snapshot_generated_storage_code() {
+        let input: syn::ItemEnum = syn::parse_quote! {
+            pub enum StorageKeys {
+                /// Instance storage with default value
+                #[instance(u32)]
+                #[default(0)]
+                Counter,
+
+                /// Persistent storage with named field and default
+                #[persistent(String)]
+                #[default("hello".to_string())]
+                Message { sender: Address },
+
+                /// Temporary storage with no auto TTL extension
+                #[temporary(bool)]
+                #[no_auto_ttl_extension]
+                Flag { key: String },
+
+                /// Persistent storage with multiple fields (no default)
+                #[persistent(Vec<u8>)]
+                Data { id: u64, name: String },
+
+                /// Persistent storage without fields or default
+                #[persistent(Address)]
+                Owner,
+
+                #[persistent(Option<Address>)]
+                OptionalData{ key: BytesN<32> }
+            }
+        };
+
+        let result = crate::storage::generate_storage(quote! { TtlProvider }, input.to_token_stream());
+        let formatted =
+            prettyplease::unparse(&syn::parse2::<syn::File>(result).expect("failed to parse generated code"));
+
+        insta::assert_snapshot!(formatted);
+    }
+}

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

@@ -0,0 +1,60 @@
+//! Default implementation macro for Stellar smart contracts.
+//!
+//! Generates a complete contract setup with:
+//! - `#[contract]` attribute
+//! - Ownable trait implementation
+//! - TtlConfigurable trait implementation with owner auth checks
+
+use proc_macro2::TokenStream as TokenStream2;
+use quote::quote;
+
+/// Generates the TtlConfigurable trait implementation for a contract.
+///
+/// The implementation delegates to `DefaultTtlConfigurable` and adds
+/// owner authentication checks for mutating functions.
+pub fn generate_ttl_configurable_impl(input: &syn::ItemStruct) -> TokenStream2 {
+    let name = &input.ident;
+    let expanded = quote! {
+        use utils::ttl::TtlConfigurable as _;
+
+        #[soroban_sdk::contractimpl]
+        impl utils::ttl::TtlConfigurable for #name {
+
+            #[common_macros::only_owner]
+            fn set_ttl_config(
+                env: &soroban_sdk::Env,
+                instance: &Option<utils::ttl::TtlConfig>,
+                persistent: &Option<utils::ttl::TtlConfig>,
+                temporary: &Option<utils::ttl::TtlConfig>,
+            ) {
+                utils::ttl::DefaultTtlConfigurable::set_ttl_config(env, instance, persistent, temporary);
+            }
+
+            fn ttl_config(
+                env: &soroban_sdk::Env,
+            ) -> (
+                Option<utils::ttl::TtlConfig>,
+                Option<utils::ttl::TtlConfig>,
+                Option<utils::ttl::TtlConfig>,
+            ) {
+                utils::ttl::DefaultTtlConfigurable::ttl_config(env)
+            }
+
+            #[common_macros::only_owner]
+            fn freeze_ttl_config(env: &soroban_sdk::Env) {
+                utils::ttl::DefaultTtlConfigurable::freeze_ttl_config(env);
+            }
+
+            fn is_ttl_config_frozen(env: &soroban_sdk::Env) -> bool {
+                utils::ttl::DefaultTtlConfigurable::is_ttl_config_frozen(env)
+            }
+        }
+    };
+
+    quote! {
+        #[common_macros::ownable]
+        #input
+
+        #expanded
+    }
+}

package/contracts/endpoint-v2/ARCHITECTURE.md

@@ -0,0 +1,233 @@
+# EndpointV2 Architecture
+
+## Overview
+
+**EndpointV2** is the core Soroban contract for LayerZero's cross-chain messaging protocol on Stellar. It serves as the central hub for omnichain applications (OApps) to send and receive cross-chain messages using pluggable message libraries.
+
+**Key Architecture Principles:**
+
+- **Interfaces exported as library** - External contracts depend on trait definitions only
+- **Contract entry point** - `endpoint_v2.rs` implements all interfaces
+- **Internal modules** - Separate files for business logic implementation
+- **Centralized resources** - Unified `storage.rs`, `errors.rs`, `events.rs`
+
+---
+
+## Project Structure
+
+```
+endpoint-v2/
+├── Cargo.toml                      # Package configuration with "library" feature
+├── ARCHITECTURE.md                 # This file - architecture documentation
+│
+├── src/
+
+│   ├── interfaces/                 # Public interface definitions (library exports)
+│   │   ├── mod.rs
+│   │   ├── layerzero_endpoint_v2.rs      # Core endpoint interface
+│   │   ├── layerzero_composer.rs         # Interface for Composer
+│   │   ├── layerzero_receiver.rs         # Interface for OApp (receive)
+│   │   ├── message_lib.rs                # Interface for MessageLib
+│   │   ├── message_lib_manager.rs        # Library management interface of EndpointV2
+│   │   ├── send_lib.rs                   # Interface for SendLib (extends MessageLib)
+│   │   ├── messaging_channel.rs          # Channel operations interface of EndpointV2
+│   │   └── messaging_composer.rs         # Compose operations interface of EndpointV2
+|   |
+│   ├── lib.rs                      # Module exports & conditional compilation
+│   ├── endpoint_v2.rs              # Main contract implementation
+│   ├── message_lib_manager.rs      # Internal: Library registration & management
+│   ├── messaging_channel.rs        # Internal: Channel logic (nonce, payload)
+│   ├── messaging_composer.rs       # Internal: Compose queue management
+│   │
+│   ├── util.rs                     # Public: Utility functions (GUID, payload, keccak256)
+│   ├── storage.rs                  # Centralized storage management
+│   ├── errors.rs                   # Centralized error definitions
+│   ├── events.rs                   # Centralized event definitions
+│   │
+│   └── tests/                      # Comprehensive test suite
+
+```
+
+---
+
+## Design Principles
+
+### 1. Interfaces as Library Exports
+
+The `interfaces/` directory contains Soroban trait definitions exported as a library for external contracts. Controlled by the `library` feature in `Cargo.toml`.
+
+```rust
+// lib.rs - conditional compilation
+cfg_if::cfg_if! {
+    if #[cfg(any(not(feature = "library"), feature = "default"))] {
+        mod endpoint_v2;  // Only included when building contract
+        mod errors;
+        mod events;
+        mod storage;
+
+        pub use endpoint_v2::{EndpointV2, EndpointV2Client};
+    }
+}
+```
+
+**Usage Example:**
+
+```rust
+// In a MessageLib contract
+use endpoint_v2::{EndpointV2Client, OutboundPacket};
+
+let endpoint = EndpointV2Client::new(&env, &endpoint_address);
+endpoint.verify(&origin, &receiver, &payload_hash);
+```
+
+**Interface Categories:**
+
+- **For OApps**: `ILayerZeroReceiver`, `ILayerZeroComposer`
+- **For MessageLibs**: `IMessageLib`, `ISendLib` (includes `OutboundPacket`, `FeeRecipient`)
+- **For All**: `ILayerZeroEndpointV2` (composes all sub-interfaces)
+- **Utilities**: `util::compute_guid()`, `util::build_payload()`, `util::keccak256()`
+
+### 2. Contract Entry Point (`endpoint_v2.rs`)
+
+The main Soroban contract that implements all interfaces and delegates to internal modules:
+
+```rust
+#[contract]
+pub struct EndpointV2;
+
+#[contractimpl]
+impl EndpointV2 {
+    pub fn __constructor(env: &Env, eid: u32, native_token: &Address, owner: &Address) {
+        storage::EndpointData::set_eid(env, eid);
+        storage::EndpointData::set_native_token(env, native_token);
+        ownable::set_owner(env, owner);
+    }
+
+    pub fn set_ttl_config(env: &Env, ...) {
+        ownable::require_owner_auth(env);
+        // Configure TTL settings for storage
+    }
+}
+
+#[contractimpl]
+impl ILayerZeroEndpointV2 for EndpointV2 {
+    fn send(env: &Env, sender: &Address, params: &MessagingParams, ...) -> MessagingReceipt {
+        sender.require_auth();
+        // Send cross-chain message via SendLib
+    }
+
+    fn lz_receive(env: &Env, origin: &Origin, receiver: &Address, ...) {
+        // Verify payload hash and deliver to OApp
+        let receiver_client = LayerZeroReceiverClient::new(env, receiver);
+        receiver_client.lz_receive(...);
+    }
+}
+
+#[contractimpl]
+impl Ownable for EndpointV2 {
+    // Ownership management
+}
+```
+
+**Implements:** `ILayerZeroEndpointV2` (which includes `IMessageLibManager`, `IMessagingChannel`, `IMessagingComposer`), `Ownable`
+
+### 3. Internal Implementation Modules
+
+Internal modules provide business logic implementation for `endpoint_v2.rs`:
+
+| Module                       | Purpose                                                                                                  |
+| ---------------------------- | -------------------------------------------------------------------------------------------------------- |
+| **`message_lib_manager.rs`** | Library registration, selection, and configuration. Tracks default/per-OApp libraries per EID.           |
+| **`messaging_channel.rs`**   | Nonce tracking, payload hash storage/verification, message state transitions (verify → receive → clear). |
+| **`messaging_composer.rs`**  | Manages compose message queues for multi-stage execution between OApp and Composers.                     |
+| **`util.rs`**                | Public utilities: `compute_guid()`, `build_payload()`, `keccak256()` for message processing.             |
+
+### 4. Centralized Resource Management
+
+| Module           | Purpose                                                                                                                                                     | Example                                                                                          |
+| ---------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------ |
+| **`storage.rs`** | Type-safe storage with `#[storage]` derive macro. Organized into: `EndpointData`, `MessagingChannelData`, `MessageLibManagerData`, `MessagingComposerData`. | `EndpointData::eid(env)`, `MessagingChannelData::outbound_nonce(env, sender, dst_eid, receiver)` |
+| **`errors.rs`**  | All error codes using `#[contracterror]`. 29 error types including validation, authorization, state, and configuration errors.                              | `InvalidNonce = 3`, `Unauthorized = 10`, `InsufficientNativeFee = 27`                            |
+| **`events.rs`**  | All events using `#[contractevent]`. Includes config, messaging, library, and compose events.                                                               | `PacketSent`, `PacketVerified`, `LibraryRegistered`                                              |
+
+---
+
+## Key Patterns
+
+**1. Interface Composition**
+
+```rust
+pub trait ILayerZeroEndpointV2:
+    IMessageLibManager + IMessagingChannel + IMessagingComposer
+{
+    fn quote(env: &Env, sender: &Address, params: &MessagingParams) -> MessagingFee;
+    fn send(env: &Env, sender: &Address, params: &MessagingParams, refund_address: &Address) -> MessagingReceipt;
+    fn lz_receive(env: &Env, origin: &Origin, receiver: &Address, guid: &BytesN<32>, message: &Bytes, extra_data: &Bytes);
+    // ... more methods
+}
+```
+
+Each sub-interface handles one domain, enabling modularity and clear separation of concerns. Ownership is handled through the `Ownable` trait from the `utils` crate.
+
+**2. Client Generation**
+
+```rust
+#[contractclient(name = "LayerZeroReceiverClient")]
+pub trait ILayerZeroReceiver {
+    fn lz_receive(env: &Env, origin: &Origin, guid: &BytesN<32>, message: &Bytes, extra_data: &Bytes);
+}
+
+// Usage: type-safe cross-contract calls
+let receiver = LayerZeroReceiverClient::new(&env, &receiver_address);
+receiver.lz_receive(&origin, &guid, &message, &extra_data);
+```
+
+The `#[contractclient]` macro automatically generates type-safe client wrappers for cross-contract calls.
+
+---
+
+## Message Flows
+
+### Sending
+
+```
+OApp → EndpointV2.send(sender, params, refund_address)
+    ↓
+    MessageLibManager.get_send_library(sender, dst_eid)
+    ↓
+    MessagingChannel.outbound_nonce++ (create OutboundPacket)
+    ↓
+    SendLib.send(packet, options, pay_in_zro) → Returns (Vec<FeeRecipient>, encoded_packet)
+    ↓
+    Pay fees (native or ZRO) to fee recipients
+    ↓
+    Emit PacketSent event
+    ↓
+    Return MessagingReceipt { guid, nonce, fee }
+```
+
+### Receiving
+
+```
+Off-chain Verifier → EndpointV2.verify(origin, receiver, payload_hash)
+    ↓
+    Validate library is registered receive lib
+    ↓
+    MessagingChannel.inbound(receiver, origin, payload_hash) → Store payload hash
+    ↓
+    Emit PacketVerified event
+
+Later: Executor → OApp.lz_receive(origin, guid, message, extra_data)
+    ↓
+    OApp executes business logic
+    ↓
+    OApp → EndpointV2.clear(caller, origin, receiver, guid, message)
+    ↓
+    Validate caller is OApp or its delegate (require_oapp_auth)
+    ↓
+    Validate payload hash matches keccak256(guid || message)
+    ↓
+    Clear payload hash from storage
+    ↓
+    Emit PacketDelivered event
+```

package/contracts/endpoint-v2/Cargo.toml

@@ -0,0 +1,30 @@
+[package]
+name = "endpoint-v2"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+publish = false
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+doctest = false
+
+[features]
+library = []
+testutils = []
+# Network selection
+mainnet = []
+testnet = []
+sandbox = []
+
+[dependencies]
+cfg-if = { workspace = true }
+soroban-sdk = { workspace = true }
+# workspace dependencies
+utils = { workspace = true }
+common-macros = { workspace = true }
+
+[dev-dependencies]
+soroban-sdk = { workspace = true, features = ["testutils"] }
+utils = { workspace = true, features = ["testutils"] }
+hex-literal = { workspace = true }

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

@@ -0,0 +1,52 @@
+//! Network-specific constants for the LayerZero Endpoint V2.
+//!
+//! This module contains configuration constants that vary by deployment environment.
+//! Constants are selected at compile time based on Cargo features.
+
+cfg_if::cfg_if! {
+    if #[cfg(any(test, feature = "testutils"))] {
+        /// Stellar Endpoint ID for unit test environment.
+        /// TODO: This is a placeholder value for testing purposes.
+        pub const STELLAR_EID: u32 = 30111;
+
+        /// Native token address for unit test environment.
+        pub const NATIVE_TOKEN: &str = "CBEPDNVYXQGWB5YUBXKJWYJA7OXTZW5LFLNO5JRRGE6Z6C5OSUZPCCEL";
+
+    } else if #[cfg(feature = "testnet")] {
+        /// Stellar Endpoint ID for testnet environment.
+        /// TODO: Confirm this EID value with LayerZero before testnet deployment.
+        pub const STELLAR_EID: u32 = 20111;
+
+        /// Native token address for testnet (Stellar testnet XLM wrapper).
+        pub const NATIVE_TOKEN: &str = "CDLZFC3SYJYDZT7K67VZ75HPJVIEUVNIXF47ZG2FB2RMQQVU2HHGCYSC";
+
+    } else if #[cfg(feature = "sandbox")] {
+        /// Stellar Endpoint ID for sandbox environment.
+        /// TODO: Confirm this EID value with LayerZero before sandbox deployment.
+        pub const STELLAR_EID: u32 = 30111;
+
+        /// Native token address for sandbox environment.
+        pub const NATIVE_TOKEN: &str = "CDMLFMKMMD7MWZP3FKUBZPVHTUEDLSX4BYGYKH4GCESXYHS3IHQ4EIG4";
+
+    } else {
+        /// Stellar Endpoint ID for mainnet environment.
+        /// TODO: Confirm this EID value with LayerZero before mainnet deployment.
+        pub const STELLAR_EID: u32 = 30111;
+
+        /// Native token address for mainnet (Stellar mainnet XLM wrapper).
+        pub const NATIVE_TOKEN: &str = "CAS3J7GYLGXMF6TDJBBYYSE3HQ6BBSMLNUQ34T6TZMYMW2EVH34XOWMA";
+    }
+}
+
+/// Represents a received message hash marker (equivalent to bytes32(uint256(1)) in Solidity )
+pub const RECEIVED_MESSAGE_HASH_BYTES: [u8; 32] =
+    [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1];
+
+/// Represents an empty payload hash (equivalent to bytes32(uint256(0)) in Solidity )
+pub const EMPTY_PAYLOAD_HASH_BYTES: [u8; 32] = [0u8; 32];
+
+/// Represents a nilified payload hash (equivalent to bytes32(type(uint256).max) in Solidity )
+pub const NIL_PAYLOAD_HASH_BYTES: [u8; 32] = [0xffu8; 32];
+
+/// Represents the maximum compose index (equivalent to uint16.max in Solidity )
+pub const MAX_COMPOSE_INDEX: u32 = u16::MAX as u32;