@layerzerolabs/protocol-stellar-v2 0.2.18 → 0.2.20

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

@@ -0,0 +1,479 @@
+//! OFT - traits and implementations for Omnichain Fungible Tokens.
+//!
+//! This module provides:
+//! - `OFTInternal`: Internal methods NOT exposed as contract entrypoints (`__debit`, `__credit`, `__initialize_oft`, etc.)
+//! - `OFTCore`: Public methods exposed as contract entrypoints (using `#[contracttrait]`)
+//! - `impl_oft_lz_receive!`: Macro to implement `LzReceiveInternal` with default OFT receive logic
+//! - Helper functions: `lz_receive` for handling incoming cross-chain transfers
+//!
+//! ## Usage
+//!
+//! ```ignore
+//! use oapp_macros::oapp;
+//! use oft_core::{OFTInternal, OFTCore, impl_oft_lz_receive};
+//!
+//! #[oapp]
+//! pub struct MyOFT;
+//!
+//! #[contractimpl]
+//! impl MyOFT {
+//!     pub fn __constructor(env: &Env, token: &Address, owner: &Address, endpoint: &Address, delegate: &Option<Address>) {
+//!         Self::__initialize_oft(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)
+//!     }
+//! }
+//!
+//! // LzReceiveInternal - use the macro for default OFT receive logic
+//! impl_oft_lz_receive!(MyOFT);
+//! ```
+
+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};
+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, 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 { ... }
+/// ```
+///
+/// This trait extends all OApp supertraits and contains both the token operations
+/// and the internal sending logic. `OFTCore` serves only as an entrypoint wrapper.
+pub trait OFTInternal: OAppCore + OAppReceiver + OAppSenderInternal + OAppOptionsType3 + OwnableInitializer {
+    // =========================================================================
+    // 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`
+    fn __initialize_oft(
+        env: &Env,
+        owner: &Address,
+        token: &Address,
+        endpoint: &Address,
+        delegate: &Option<Address>,
+        shared_decimals: u32,
+    ) {
+        // Initialize OApp (includes owner initialization)
+        initialize_oapp::<Self>(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));
+    }
+
+    // =========================================================================
+    // 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)
+    // =========================================================================
+
+    // ----- Quote Methods -----
+
+    /// Quotes an OFT transfer without executing.
+    ///
+    /// The default implementation has no send limits (`min_amount_ld: 0`, `max_amount_ld: i128::MAX`)
+    /// and no fee details (empty vector). Override this method to implement custom limits or fees.
+    ///
+    /// # Arguments
+    /// * `send_param` - The send parameters to quote
+    ///
+    /// # Returns
+    /// A tuple of (transfer limits, fee details, estimated receipt)
+    fn __quote_oft(env: &Env, send_param: &SendParam) -> (OFTLimit, Vec<OFTFeeDetail>, OFTReceipt) {
+        let limit = OFTLimit { min_amount_ld: 0, max_amount_ld: i128::MAX };
+        let fee_details = vec![env];
+        let oft_receipt = Self::__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
+    fn __quote_send(env: &Env, from: &Address, send_param: &SendParam, pay_in_zro: bool) -> MessagingFee {
+        let OFTReceipt { amount_received_ld, .. } =
+            Self::__debit_view(env, send_param.amount_ld, send_param.min_amount_ld, send_param.dst_eid);
+
+        let (msg, options) = Self::__build_msg_and_options(env, from, send_param, amount_received_ld);
+        Self::__quote(env, send_param.dst_eid, &msg, &options, pay_in_zro)
+    }
+
+    // ----- Send Method -----
+
+    /// 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)
+    fn __send(
+        env: &Env,
+        from: &Address,
+        send_param: &SendParam,
+        fee: &MessagingFee,
+        refund_address: &Address,
+    ) -> (MessagingReceipt, OFTReceipt) {
+        from.require_auth();
+
+        let oft_receipt = Self::__debit(env, from, send_param.amount_ld, send_param.min_amount_ld, send_param.dst_eid);
+
+        let (msg, options) = Self::__build_msg_and_options(env, from, send_param, oft_receipt.amount_received_ld);
+        let msg_receipt = Self::__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)
+    }
+
+    // ----- View/Helper Methods -----
+
+    /// Simulates a debit operation without executing, used for quoting.
+    ///
+    /// The default implementation does not charge any fee, so `amount_sent_ld` equals
+    /// `amount_received_ld` (after dust removal). Override this method to implement
+    /// custom fee logic.
+    ///
+    /// # 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
+    ///
+    /// # Panics
+    /// * `OFTError::SlippageExceeded` - If `amount_received_ld` is less than `min_amount_ld`
+    fn __debit_view(env: &Env, amount_ld: i128, min_amount_ld: i128, _dst_eid: u32) -> OFTReceipt {
+        let conversion_rate = Self::__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 OFT message and combines 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)
+    fn __build_msg_and_options(
+        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 = Self::__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, Self::combine_options(env, send_param.dst_eid, msg_type, &send_param.extra_options))
+    }
+
+    // ----- Storage Accessors -----
+
+    /// Retrieves the token address associated with this OFT.
+    fn __token(env: &Env) -> Address {
+        OFTStorage::token(env).unwrap_or_panic(env, OFTError::NotInitialized)
+    }
+
+    /// Retrieves the decimal conversion rate used for cross-chain normalization.
+    fn __decimal_conversion_rate(env: &Env) -> i128 {
+        OFTStorage::decimal_conversion_rate(env).unwrap_or_panic(env, OFTError::NotInitialized)
+    }
+
+    /// Retrieves the shared decimals used for cross-chain normalization.
+    fn __shared_decimals(env: &Env) -> u32 {
+        let token = Self::__token(env);
+        let local_decimals = TokenClient::new(env, &token).decimals();
+        let conversion_rate = Self::__decimal_conversion_rate(env);
+        local_decimals - conversion_rate.ilog10()
+    }
+}
+
+// ===========================================================================
+// 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)]`.
+///
+/// This trait only exposes entrypoints. All internal logic is in `OFTInternal`.
+#[contract_trait(client_name = "OFTClient")]
+pub trait OFTCore: OFTInternal {
+    /// Retrieves the token address associated with this OFT.
+    fn token(env: &soroban_sdk::Env) -> soroban_sdk::Address {
+        Self::__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 {
+        Self::__shared_decimals(env)
+    }
+
+    /// Retrieves the decimal conversion rate used for cross-chain normalization.
+    fn decimal_conversion_rate(env: &soroban_sdk::Env) -> i128 {
+        Self::__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) {
+        Self::__quote_oft(env, send_param)
+    }
+
+    /// Quotes a send operation including LayerZero messaging fees.
+    fn quote_send(
+        env: &soroban_sdk::Env,
+        from: &soroban_sdk::Address,
+        send_param: &oft_core::types::SendParam,
+        pay_in_zro: bool,
+    ) -> endpoint_v2::MessagingFee {
+        Self::__quote_send(env, from, send_param, pay_in_zro)
+    }
+
+    /// Sends tokens cross-chain to another endpoint.
+    ///
+    /// From must be authenticated.
+    ///
+    /// # Returns
+    /// (MessagingReceipt, OFTReceipt)
+    fn send(
+        env: &soroban_sdk::Env,
+        from: &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) {
+        Self::__send(env, from, send_param, fee, refund_address)
+    }
+}
+
+// ===========================================================================
+// LzReceive Handler (called by OAppReceiver)
+// ===========================================================================
+
+/// Implements `LzReceiveInternal` for an OFT contract using the default OFT receive logic.
+///
+/// This macro generates the boilerplate `LzReceiveInternal` implementation that delegates
+/// to `oft_core::lz_receive`, which handles decoding the OFT message, crediting tokens
+/// to the recipient, and optionally queuing compose messages.
+///
+/// # Usage
+///
+/// ```ignore
+/// use oft_core::impl_oft_lz_receive;
+///
+/// #[oapp]
+/// pub struct MyOFT;
+///
+/// impl OFTInternal for MyOFT {
+///     // ... implement __debit and __credit ...
+/// }
+///
+/// // Instead of manually implementing LzReceiveInternal:
+/// impl_oft_lz_receive!(MyOFT);
+/// ```
+#[macro_export]
+macro_rules! impl_oft_lz_receive {
+    ($contract:ty) => {
+        impl oapp::oapp_receiver::LzReceiveInternal for $contract {
+            fn __lz_receive(
+                env: &soroban_sdk::Env,
+                origin: &endpoint_v2::Origin,
+                guid: &soroban_sdk::BytesN<32>,
+                message: &soroban_sdk::Bytes,
+                extra_data: &soroban_sdk::Bytes,
+                executor: &soroban_sdk::Address,
+                value: i128,
+            ) {
+                oft_core::lz_receive::<Self>(env, executor, origin, guid, message, extra_data, value)
+            }
+        }
+    };
+}
+
+/// 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: &soroban_sdk::Env,
+    _executor: &soroban_sdk::Address,
+    origin: &endpoint_v2::Origin,
+    guid: &soroban_sdk::BytesN<32>,
+    message: &soroban_sdk::Bytes,
+    _extra_data: &soroban_sdk::Bytes,
+    _value: i128,
+) {
+    let oft_msg = OFTMessage::decode(message);
+    let send_to = oft_utils::resolve_address(env, &oft_msg.send_to);
+
+    let conversion_rate = T::__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/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_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,4 +1,4 @@
-use crate::{codec::oft_msg_codec::OFTMessage, 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]
@@ -33,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);
@@ -66,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,
     };
 
@@ -105,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);