@layerzerolabs/protocol-stellar-v2 0.2.15 → 0.2.19

package/contracts/oapps/oft-core/src/oft_core.rs

@@ -0,0 +1,439 @@
+//! OFT - traits and implementations for Omnichain Fungible Tokens.
+//!
+//! This module provides:
+//! - `OFTInternal`: Internal methods NOT exposed as contract entrypoints (`__debit`, `__credit`, etc.)
+//! - `OFTCore`: Public methods exposed as contract entrypoints (using `#[contracttrait]`)
+//! - Core functions: `initialize_oft`, `lz_receive`, and other helpers
+//!
+//! ## Usage
+//!
+//! ```ignore
+//! use oapp_macros::{oapp, oapp_options_type3};
+//! use oft_core::{OFTInternal, OFTCore, initialize_oft};
+//!
+//! #[oapp]
+//! pub struct MyOFT;
+//!
+//! #[contractimpl]
+//! impl MyOFT {
+//!     pub fn __constructor(env: &Env, token: &Address, owner: &Address, endpoint: &Address, delegate: &Option<Address>) {
+//!         initialize_oft::<Self>(env, owner, token, endpoint, delegate, 6)
+//!     }
+//! }
+//!
+//! // Public methods - exposed as contract entrypoints
+//! #[contractimpl(contracttrait)]
+//! impl OFTCore for MyOFT {}
+//!
+//! // Internal methods - NOT exposed as contract entrypoints
+//! // IMPORTANT: Do NOT use #[contractimpl] here to keep methods internal
+//! impl OFTInternal for MyOFT {
+//!     fn __debit(env: &Env, sender: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
+//!         // Your debit logic (e.g., burn or lock tokens)
+//!         oft_core::oft_types::mint_burn::debit::<Self>(env, sender, amount_ld, min_amount_ld, dst_eid)
+//!     }
+//!
+//!     fn __credit(env: &Env, to: &Address, amount_ld: i128, src_eid: u32) -> i128 {
+//!         // Your credit logic (e.g., mint or unlock tokens)
+//!         oft_core::oft_types::mint_burn::credit::<Self>(env, to, amount_ld, src_eid)
+//!     }
+//! }
+//! ```
+
+use crate::{
+    self as oft_core,
+    codec::{oft_compose_msg_codec::OFTComposeMsg, oft_msg_codec::OFTMessage},
+    errors::OFTError,
+    events::{self, OFTSent},
+    storage::OFTStorage,
+    types::{self, OFTFeeDetail, OFTLimit, OFTReceipt, SendParam},
+    utils as oft_utils,
+};
+use common_macros::contract_trait;
+use endpoint_v2::{MessagingComposerClient, MessagingFee, MessagingReceipt, Origin};
+use oapp::{
+    oapp_core::{initialize_oapp, OAppCore},
+    oapp_options_type3::OAppOptionsType3,
+    oapp_receiver::OAppReceiver,
+    oapp_sender::OAppSenderInternal,
+};
+use soroban_sdk::{assert_with_error, token::TokenClient, vec, Address, Bytes, BytesN, Env, Vec};
+use utils::{option_ext::OptionExt, ownable::OwnableInitializer};
+
+// ===========================================================================
+// OFTInternal Trait (NOT exposed as contract entrypoints)
+// ===========================================================================
+
+/// Internal OFT trait containing methods that should NOT be exposed as contract entrypoints.
+///
+/// **IMPORTANT**: Implement this trait WITHOUT the `#[contractimpl]` macro to keep
+/// `__debit`, `__credit`, and other internal methods private to the contract.
+///
+/// ```ignore
+/// // Correct - methods stay internal
+/// impl OFTInternal for MyOFT { ... }
+///
+/// // WRONG - would expose methods as entrypoints
+/// #[contractimpl]
+/// impl OFTInternal for MyOFT { ... }
+/// ```
+///
+/// Internal OFT trait for token debit/credit operations.
+///
+/// This trait contains only the internal token operations. The OApp supertraits
+/// are on `OFTCore` instead, keeping this trait focused on token logic.
+pub trait OFTInternal: OAppCore + OAppOptionsType3 {
+    // =========================================================================
+    // Required Methods (no defaults - user MUST implement)
+    // =========================================================================
+
+    /// Debits tokens from the specified address for cross-chain transfer.
+    ///
+    /// # Arguments
+    /// * `from` - The address to debit the tokens from
+    /// * `amount_ld` - The amount of tokens to send in local decimals
+    /// * `min_amount_ld` - The minimum amount to send in local decimals
+    /// * `dst_eid` - The destination chain ID
+    ///
+    /// # Returns
+    /// `OFTReceipt` containing the amount sent and amount received
+    fn __debit(env: &Env, from: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt;
+
+    /// Credits tokens to recipient after receiving cross-chain transfer.
+    ///
+    /// # Arguments
+    /// * `to` - The address to credit tokens to
+    /// * `amount_ld` - Amount in local decimals to credit
+    /// * `src_eid` - Source endpoint ID
+    ///
+    /// # Returns
+    /// The amount actually credited
+    fn __credit(env: &Env, to: &Address, amount_ld: i128, src_eid: u32) -> i128;
+
+    // =========================================================================
+    // Optional Methods (have defaults - override as needed)
+    // =========================================================================
+
+    /// Calculates debit amounts without executing (view function).
+    fn __debit_view(env: &Env, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
+        debit_view(env, amount_ld, min_amount_ld, dst_eid)
+    }
+
+    /// Builds OFT message and combines options for cross-chain transfer.
+    fn __build_msg_and_options(
+        env: &Env,
+        from: &Address,
+        send_param: &oft_core::types::SendParam,
+        receive_amount_ld: i128,
+    ) -> (Bytes, Bytes) {
+        build_msg_and_options::<Self>(env, from, send_param, receive_amount_ld)
+    }
+}
+
+// ===========================================================================
+// OFTCore Trait (exposed as contract entrypoints)
+// ===========================================================================
+
+/// The public OFT trait defining the cross-chain token transfer interface.
+///
+/// This trait is marked with `#[contracttrait]` so all its methods are exposed as
+/// contract entrypoints. Users implement this with `#[contractimpl(contracttrait)]`.
+///
+/// Internal methods like `__debit`, `__credit`, `__debit_view`, and `__build_msg_and_options`
+/// are in the `OFTInternal` trait and are NOT exposed as contract entrypoints.
+#[contract_trait(client_name = "OFTClient")]
+pub trait OFTCore: OFTInternal + OAppReceiver + OAppSenderInternal + OAppOptionsType3 {
+    /// Retrieves the token address associated with this OFT.
+    fn token(env: &soroban_sdk::Env) -> soroban_sdk::Address {
+        token(env)
+    }
+
+    /// Returns OFT version as (major, minor).
+    fn oft_version(_env: &soroban_sdk::Env) -> (u64, u64) {
+        (1, 1)
+    }
+
+    /// Retrieves the shared decimals used for cross-chain normalization.
+    fn shared_decimals(env: &soroban_sdk::Env) -> u32 {
+        shared_decimals(env)
+    }
+
+    /// Retrieves the decimal conversion rate used for cross-chain normalization.
+    fn decimal_conversion_rate(env: &soroban_sdk::Env) -> i128 {
+        decimal_conversion_rate(env)
+    }
+
+    /// Whether a separate token approval is required before sending.
+    ///
+    /// Helps wallet implementers determine integration requirements.
+    ///
+    /// # Returns
+    /// - `true` if a separate token approval step is required
+    /// - `false` if no separate approval is needed
+    fn approval_required(_env: &soroban_sdk::Env) -> bool {
+        false
+    }
+
+    /// Quotes an OFT transfer without executing.
+    ///
+    /// # Returns
+    /// (OFTLimit, fee details, receipt with estimated amounts)
+    fn quote_oft(
+        env: &soroban_sdk::Env,
+        send_param: &oft_core::types::SendParam,
+    ) -> (oft_core::types::OFTLimit, soroban_sdk::Vec<oft_core::types::OFTFeeDetail>, oft_core::types::OFTReceipt) {
+        quote_oft::<Self>(env, send_param)
+    }
+
+    /// Quotes a send operation including LayerZero messaging fees.
+    fn quote_send(
+        env: &soroban_sdk::Env,
+        sender: &soroban_sdk::Address,
+        send_param: &oft_core::types::SendParam,
+        pay_in_zro: bool,
+    ) -> endpoint_v2::MessagingFee {
+        quote_send::<Self>(env, sender, send_param, pay_in_zro)
+    }
+
+    /// Sends tokens cross-chain to another endpoint.
+    ///
+    /// Sender must be authenticated.
+    ///
+    /// # Returns
+    /// (MessagingReceipt, OFTReceipt)
+    fn send(
+        env: &soroban_sdk::Env,
+        sender: &soroban_sdk::Address,
+        send_param: &oft_core::types::SendParam,
+        fee: &endpoint_v2::MessagingFee,
+        refund_address: &soroban_sdk::Address,
+    ) -> (endpoint_v2::MessagingReceipt, oft_core::types::OFTReceipt) {
+        send::<Self>(env, sender, send_param, fee, refund_address)
+    }
+}
+
+// ===========================================================================
+// Initialization
+// ===========================================================================
+
+/// Initializes the OFT (Omnichain Fungible Token) contract.
+///
+/// Sets up the OApp infrastructure and configures decimal conversion for cross-chain transfers.
+/// The `shared_decimals` parameter defines the common decimal precision used across all chains,
+/// enabling consistent token amounts regardless of each chain's native token decimals.
+///
+/// # Arguments
+/// * `owner` - The address that will own this OFT contract
+/// * `token` - The underlying token contract address (must implement SEP-41 token interface)
+/// * `endpoint` - The LayerZero endpoint address for cross-chain messaging
+/// * `delegate` - Optional delegate address for endpoint configuration permissions
+/// * `shared_decimals` - The shared decimal precision for cross-chain compatibility (must be <= local decimals)
+///
+/// # Panics
+/// * `OFTError::InvalidLocalDecimals` - If the token's local decimals are less than `shared_decimals`
+pub fn initialize_oft<T: OFTCore + OwnableInitializer>(
+    env: &Env,
+    owner: &Address,
+    token: &Address,
+    endpoint: &Address,
+    delegate: &Option<Address>,
+    shared_decimals: u32,
+) {
+    // Initialize OApp (includes owner initialization)
+    initialize_oapp::<T>(env, owner, endpoint, delegate);
+
+    let local_decimals = TokenClient::new(env, token).decimals();
+    assert_with_error!(env, local_decimals >= shared_decimals, OFTError::InvalidLocalDecimals);
+
+    // Initialize OFT storage
+    OFTStorage::set_token(env, token);
+    OFTStorage::set_decimal_conversion_rate(env, &10_i128.pow(local_decimals - shared_decimals));
+}
+
+// ===========================================================================
+// Implementation Functions
+// ===========================================================================
+
+/// Simulates a debit operation without executing, used for quoting.
+///
+/// # Arguments
+/// * `amount_ld` - The amount of tokens to send in local decimals
+/// * `min_amount_ld` - The minimum amount to send in local decimals (slippage protection)
+/// * `dst_eid` - The destination chain ID (unused in default implementation)
+///
+/// # Returns
+/// `OFTReceipt` containing the amount sent and amount received after dust removal
+pub fn debit_view(env: &Env, amount_ld: i128, min_amount_ld: i128, _dst_eid: u32) -> OFTReceipt {
+    let conversion_rate = decimal_conversion_rate(env);
+    let amount_sent_ld = oft_utils::remove_dust(amount_ld, conversion_rate);
+    let amount_received_ld = amount_sent_ld;
+
+    assert_with_error!(env, amount_received_ld >= min_amount_ld, OFTError::SlippageExceeded);
+
+    OFTReceipt { amount_sent_ld, amount_received_ld }
+}
+
+/// Builds the OFT message payload and combines enforced options for cross-chain transfer.
+///
+/// # Arguments
+/// * `from` - The address initiating the transfer
+/// * `send_param` - The send parameters including destination, recipient, and options
+/// * `receive_amount_ld` - The amount to be received in local decimals (after dust removal)
+///
+/// # Returns
+/// A tuple of (encoded message, combined options)
+pub fn build_msg_and_options<T: OAppOptionsType3>(
+    env: &Env,
+    from: &Address,
+    send_param: &SendParam,
+    receive_amount_ld: i128,
+) -> (Bytes, Bytes) {
+    let has_compose = !send_param.compose_msg.is_empty();
+    let conversion_rate = decimal_conversion_rate(env);
+    let (msg, _) = OFTMessage {
+        send_to: send_param.to.clone(),
+        amount_sd: oft_utils::to_sd(env, receive_amount_ld, conversion_rate),
+        compose_from: if has_compose { Some(oft_utils::address_payload(from)) } else { None },
+        compose_msg: if has_compose { Some(send_param.compose_msg.clone()) } else { None },
+    }
+    .encode(env);
+    let msg_type = if has_compose { types::SEND_AND_CALL } else { types::SEND };
+
+    (msg, T::combine_options(env, send_param.dst_eid, msg_type, &send_param.extra_options))
+}
+
+/// Quotes an OFT transfer without executing.
+///
+/// # Arguments
+/// * `send_param` - The send parameters to quote
+///
+/// # Returns
+/// A tuple of (transfer limits, fee details, estimated receipt)
+pub fn quote_oft<T: OFTInternal>(env: &Env, send_param: &SendParam) -> (OFTLimit, Vec<OFTFeeDetail>, OFTReceipt) {
+    let limit = OFTLimit { min_amount_ld: 0, max_amount_ld: i128::MAX }; // No limits in default implementation
+    let fee_details = vec![env]; // No fee details in default implementation
+    let oft_receipt = T::__debit_view(env, send_param.amount_ld, send_param.min_amount_ld, send_param.dst_eid);
+    (limit, fee_details, oft_receipt)
+}
+
+/// Quotes the LayerZero messaging fee for a send operation.
+///
+/// # Arguments
+/// * `from` - The address initiating the transfer
+/// * `send_param` - The send parameters to quote
+/// * `pay_in_zro` - Whether to pay the fee in ZRO token
+///
+/// # Returns
+/// The messaging fee required for the transfer
+pub fn quote_send<T: OFTCore>(env: &Env, from: &Address, send_param: &SendParam, pay_in_zro: bool) -> MessagingFee {
+    let OFTReceipt { amount_received_ld, .. } =
+        T::__debit_view(env, send_param.amount_ld, send_param.min_amount_ld, send_param.dst_eid);
+
+    let (msg, options) = build_msg_and_options::<T>(env, from, send_param, amount_received_ld);
+    T::__quote(env, send_param.dst_eid, &msg, &options, pay_in_zro)
+}
+
+/// Executes a cross-chain token transfer via LayerZero.
+///
+/// Debits tokens from the `from` address, builds the message, and sends via the endpoint.
+/// The `from` address must be authenticated.
+///
+/// # Arguments
+/// * `from` - The address sending tokens (must authorize)
+/// * `send_param` - The send parameters (destination, recipient, amount, options)
+/// * `fee` - The messaging fee to pay
+/// * `refund_address` - The address to refund excess fees to
+///
+/// # Returns
+/// A tuple of (messaging receipt, OFT receipt with amounts)
+pub fn send<T: OFTCore>(
+    env: &Env,
+    from: &Address,
+    send_param: &SendParam,
+    fee: &MessagingFee,
+    refund_address: &Address,
+) -> (MessagingReceipt, OFTReceipt) {
+    from.require_auth();
+
+    let oft_receipt = T::__debit(env, from, send_param.amount_ld, send_param.min_amount_ld, send_param.dst_eid);
+
+    let (msg, options) = build_msg_and_options::<T>(env, from, send_param, oft_receipt.amount_received_ld);
+    let msg_receipt = T::__lz_send(env, send_param.dst_eid, &msg, &options, from, fee, refund_address);
+
+    OFTSent {
+        guid: msg_receipt.guid.clone(),
+        dst_eid: send_param.dst_eid,
+        from: from.clone(),
+        amount_sent_ld: oft_receipt.amount_sent_ld,
+        amount_received_ld: oft_receipt.amount_received_ld,
+    }
+    .publish(env);
+
+    (msg_receipt, oft_receipt)
+}
+
+/// Retrieves the decimal conversion rate used for cross-chain normalization.
+pub fn decimal_conversion_rate(env: &Env) -> i128 {
+    OFTStorage::decimal_conversion_rate(env).unwrap_or_panic(env, OFTError::NotInitialized)
+}
+
+/// Retrieves the token address associated with this OFT.
+pub fn token(env: &Env) -> Address {
+    OFTStorage::token(env).unwrap_or_panic(env, OFTError::NotInitialized)
+}
+
+/// Retrieves the shared decimals used for cross-chain normalization.
+pub fn shared_decimals(env: &Env) -> u32 {
+    let token = token(env);
+    let local_decimals = TokenClient::new(env, &token).decimals();
+    let conversion_rate = decimal_conversion_rate(env);
+    local_decimals - conversion_rate.ilog10()
+}
+
+// ===========================================================================
+// LzReceive Handler (called by OAppReceiver)
+// ===========================================================================
+
+/// Handles incoming cross-chain OFT transfer from LayerZero endpoint.
+///
+/// Credits tokens to the recipient and optionally queues a compose message.
+///
+/// # Arguments
+/// * `executor` - The address of the executor handling the message (unused in default implementation)
+/// * `origin` - The origin information (source chain, sender, nonce)
+/// * `guid` - The unique message identifier
+/// * `message` - The encoded OFT message payload
+/// * `extra_data` - Additional data (unused in default implementation)
+/// * `value` - The native token value sent with the message (unused in default implementation)
+pub fn lz_receive<T: OFTInternal>(
+    env: &Env,
+    _executor: &Address,
+    origin: &Origin,
+    guid: &BytesN<32>,
+    message: &Bytes,
+    _extra_data: &Bytes,
+    _value: i128,
+) {
+    let oft_msg = OFTMessage::decode(message);
+    let send_to = oft_utils::resolve_address(env, &oft_msg.send_to);
+
+    let conversion_rate = decimal_conversion_rate(env);
+    let amount_received_ld =
+        T::__credit(env, &send_to, oft_utils::to_ld(oft_msg.amount_sd, conversion_rate), origin.src_eid);
+
+    if oft_msg.is_composed() {
+        let compose_msg = OFTComposeMsg {
+            nonce: origin.nonce,
+            src_eid: origin.src_eid,
+            amount_ld: amount_received_ld,
+            compose_from: oft_msg.compose_from.unwrap(),
+            compose_msg: oft_msg.compose_msg.unwrap(),
+        }
+        .encode(env);
+
+        let endpoint_client = MessagingComposerClient::new(env, &T::endpoint(env));
+        endpoint_client.send_compose(&env.current_contract_address(), &send_to, guid, &0, &compose_msg);
+    }
+
+    events::OFTReceived { guid: guid.clone(), src_eid: origin.src_eid, to: send_to, amount_received_ld }.publish(env);
+}

package/contracts/oapps/{oft → oft-core}/src/storage.rs

@@ -3,9 +3,11 @@ use soroban_sdk::Address;
 
 #[storage]
 pub enum OFTStorage {
+    /// The decimal conversion rate used for cross-chain normalization
     #[instance(i128)]
     DecimalConversionRate,
 
+    /// The address of the underlying token contract
     #[instance(Address)]
     Token,
 }

package/contracts/oapps/{oft → oft-core}/src/tests/mod.rs

@@ -11,5 +11,3 @@ pub mod test_quote_send;
 pub mod test_resolve_address;
 pub mod test_send;
 pub mod test_token;
-
-pub mod extensions;

package/contracts/oapps/{oft → oft-core}/src/tests/test_decimals.rs

@@ -17,7 +17,7 @@ fn test_decimal_conversion_rate() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #2100)")] // InvalidLocalDecimals
+#[should_panic(expected = "Error(Contract, #3000)")] // InvalidLocalDecimals
 fn test_invalid_local_decimals() {
     let env = Env::default();
     OFTTestSetupBuilder::new(&env).with_token_decimals(5).with_shared_decimals(6).build();
@@ -34,7 +34,7 @@ fn test_to_ld_overflow() {
 }
 
 #[test]
-#[should_panic(expected = "Error(Contract, #2101)")] // Overflow
+#[should_panic(expected = "Error(Contract, #3002)")] // Overflow
 fn test_to_sd_overflow() {
     let env = Env::default();
 

package/contracts/oapps/{oft → oft-core}/src/tests/test_lz_receive.rs

@@ -5,7 +5,7 @@ use crate::{
         create_origin, create_recipient_address, encode_oft_message, encode_oft_message_with_compose,
         generate_g_address, OFTTestSetupBuilder,
     },
-    utils::address_to_bytes32,
+    utils::address_payload,
 };
 use endpoint_v2::LayerZeroReceiverClient;
 use soroban_sdk::{testutils::Address as _, Address, Bytes, BytesN, Env};
@@ -26,7 +26,7 @@ fn run_lz_receive_test(setup: &OFTTestSetup, recipient: &Address, amount_sd: u64
         if setup.is_lock_unlock() { Some(setup.token_client.balance(&setup.oft.address)) } else { None };
 
     // Create OFT message
-    let recipient_bytes32 = address_to_bytes32(recipient);
+    let recipient_bytes32 = address_payload(recipient);
     let message = encode_oft_message(env, &recipient_bytes32, amount_sd);
 
     let guid = BytesN::from_array(env, &[1u8; 32]);
@@ -111,8 +111,8 @@ fn test_mint_burn_lz_receive_with_compose() {
     setup.set_peer(src_eid, &peer);
 
     // Create OFT message with compose
-    let recipient_bytes32 = address_to_bytes32(&recipient);
-    let compose_from = address_to_bytes32(&sender_on_src);
+    let recipient_bytes32 = address_payload(&recipient);
+    let compose_from = address_payload(&sender_on_src);
     let compose_msg = Bytes::from_array(&env, b"test compose payload");
     let amount_sd = 1000000u64;
     let message = encode_oft_message_with_compose(&env, &recipient_bytes32, amount_sd, &compose_from, &compose_msg);
@@ -204,8 +204,8 @@ fn test_lock_unlock_lz_receive_with_compose() {
     setup.set_peer(src_eid, &peer);
 
     // Create OFT message with compose
-    let recipient_bytes32 = address_to_bytes32(&recipient);
-    let compose_from = address_to_bytes32(&sender_on_src);
+    let recipient_bytes32 = address_payload(&recipient);
+    let compose_from = address_payload(&sender_on_src);
     let compose_msg = Bytes::from_array(&env, b"test compose payload");
     let amount_sd = 1000000u64;
     let message = encode_oft_message_with_compose(&env, &recipient_bytes32, amount_sd, &compose_from, &compose_msg);
@@ -261,7 +261,7 @@ fn test_lz_receive_without_giving_authorization() {
     assert_eq!(setup.token_client.balance(&recipient), 0);
 
     // Create OFT message
-    let recipient_bytes32 = address_to_bytes32(&recipient);
+    let recipient_bytes32 = address_payload(&recipient);
     let amount_sd = 1000000u64; // 1 token in shared decimals
     let message = encode_oft_message(&env, &recipient_bytes32, amount_sd);
 

package/contracts/oapps/{oft → oft-core}/src/tests/test_oft_msg_codec.rs

@@ -1,5 +1,4 @@
-use crate::codec::oft_msg_codec::OFTMessage;
-use crate::utils::address_to_bytes32;
+use crate::{codec::oft_msg_codec::OFTMessage, utils::address_payload};
 use soroban_sdk::{testutils::Address as _, Address, Bytes, BytesN, Env};
 
 #[test]
@@ -34,7 +33,7 @@ fn test_encode_and_decode_with_compose() {
     let msg = OFTMessage {
         send_to: send_to_addr.clone(),
         amount_sd: amount_sd_val,
-        compose_from: Some(address_to_bytes32(&sender)),
+        compose_from: Some(address_payload(&sender)),
         compose_msg: Some(compose_msg_val),
     };
     let (encoded, has_compose) = msg.encode(&env);
@@ -67,7 +66,7 @@ fn test_is_composed_false_when_only_compose_from() {
     let msg = OFTMessage {
         send_to: send_to_addr,
         amount_sd: amount_sd_val,
-        compose_from: Some(address_to_bytes32(&sender)),
+        compose_from: Some(address_payload(&sender)),
         compose_msg: None,
     };
 
@@ -106,7 +105,7 @@ fn test_is_composed_false_when_compose_msg_empty() {
     let msg = OFTMessage {
         send_to: send_to_addr.clone(),
         amount_sd: amount_sd_val,
-        compose_from: Some(address_to_bytes32(&sender)),
+        compose_from: Some(address_payload(&sender)),
         compose_msg: Some(empty_compose_msg),
     };
 

package/contracts/oapps/{oft → oft-core}/src/tests/test_resolve_address.rs

@@ -1,6 +1,6 @@
 use crate::{
     tests::test_utils::{create_recipient_address, generate_g_address},
-    utils::{address_to_bytes32, resolve_address},
+    utils::{address_payload, resolve_address},
 };
 use soroban_sdk::Env;
 
@@ -12,7 +12,7 @@ fn test_resolve_address_contract_exists() {
     let contract_address = create_recipient_address(&env);
 
     // Convert to bytes32
-    let bytes32 = address_to_bytes32(&contract_address);
+    let bytes32 = address_payload(&contract_address);
 
     // Resolve back - should return the same contract address
     let resolved = resolve_address(&env, &bytes32);
@@ -28,7 +28,7 @@ fn test_resolve_address_contract_not_exists_fallback_to_g_address() {
     let g_address = generate_g_address(&env);
 
     // Convert to bytes32
-    let bytes32 = address_to_bytes32(&g_address);
+    let bytes32 = address_payload(&g_address);
 
     // Resolve - should fallback to G-address since contract doesn't exist
     let resolved = resolve_address(&env, &bytes32);