@layerzerolabs/protocol-stellar-v2 0.2.13 → 0.2.18

package/contracts/oapps/{counter/integration_tests → oft-std/integration-tests}/setup.rs

@@ -1,48 +1,92 @@
+//! Integration test setup for OFT-STD with real EndpointV2 and SimpleMessageLib.
+//!
+//! This file contains test setup utilities for OFT-STD with all extensions enabled.
+
+extern crate self as oft_std;
 extern crate std;
 
 use crate::{
-    counter::{Counter, CounterClient},
-    integration_tests::utils::address_to_bytes32,
+    integration_tests::utils::{address_to_peer_bytes32, peer_bytes32_to_address},
+    oft::{OFTMode, OFTStd, OFTStdClient},
 };
 use endpoint_v2::{EndpointV2, EndpointV2Client};
 use simple_message_lib::{SimpleMessageLib, SimpleMessageLibClient};
 use soroban_sdk::{
-    address_payload::AddressPayload,
-    log,
+    contract, contractimpl, log,
     testutils::{Address as _, MockAuth, MockAuthInvoke},
+    token::TokenClient,
     Address, BytesN, Env, IntoVal,
 };
-use utils::buffer_reader::BufferReader;
+
+// ============================================================================
+// Dummy Recipient - used to create valid contract addresses for recipients
+// ============================================================================
+
+#[contract]
+pub struct DummyRecipient;
+
+#[contractimpl]
+impl DummyRecipient {
+    pub fn __constructor(_env: &Env) {}
+}
+
+/// Creates a valid recipient address by deploying a dummy contract.
+/// Use this in tests when the address needs to pass the `.exists()` check.
+pub fn create_recipient_address(env: &Env) -> Address {
+    env.register(DummyRecipient, ())
+}
+
+// ============================================================================
+// Test Setup
+// ============================================================================
 
 pub struct ChainSetup<'a> {
     pub eid: u32,
     pub owner: Address,
     pub native_token: Address,
+    pub zro_token: Address,
+    pub oft_token: Address,
     pub endpoint: EndpointV2Client<'a>,
     pub sml: SimpleMessageLibClient<'a>,
-    pub counter: CounterClient<'a>,
+    pub oft: OFTStdClient<'a>,
+    pub fee_collector: Address,
 }
 
 pub struct TestSetup<'a> {
     pub env: Env,
-
     pub chain_a: ChainSetup<'a>,
     pub chain_b: ChainSetup<'a>,
 }
 
-fn setup_chain<'a>(env: &Env, owner: &Address) -> ChainSetup<'a> {
+fn setup_chain<'a>(env: &Env) -> ChainSetup<'a> {
+    let owner = Address::generate(env);
+
+    // Create native token FIRST - this must match the endpoint's NATIVE_TOKEN constant
+    let sac = env.register_stellar_asset_contract_v2(owner.clone());
+    let native_token = sac.address();
+
+    // Generate fee_collector AFTER native_token to not affect the address derivation
+    let fee_collector = Address::generate(env);
+
     // Create ZRO token
     let zro_sac = env.register_stellar_asset_contract_v2(owner.clone());
     let zro_token = zro_sac.address();
 
-    let endpoint_address = env.register(EndpointV2, (owner,));
+    // Create OFT token
+    let oft_sac = env.register_stellar_asset_contract_v2(owner.clone());
+    let oft_token = oft_sac.address();
+
+    let endpoint_address = env.register(EndpointV2, (&owner,));
     let fee_recipient = Address::generate(env);
-    let sml_address = env.register(SimpleMessageLib, (owner, &endpoint_address, &fee_recipient));
-    let counter_address = env.register(Counter, (owner, &endpoint_address, owner));
+    let sml_address = env.register(SimpleMessageLib, (&owner, &endpoint_address, &fee_recipient));
+    let delegate: Option<Address> = Some(owner.clone());
+    let shared_decimals: u32 = 6; // Default shared decimals
+    let mode = OFTMode::MintBurn;
+    let oft_address = env.register(OFTStd, (&oft_token, &owner, &endpoint_address, &delegate, &shared_decimals, &mode));
 
     let endpoint = EndpointV2Client::new(env, &endpoint_address);
     let sml = SimpleMessageLibClient::new(env, &sml_address);
-    let counter = CounterClient::new(env, &counter_address);
+    let oft = OFTStdClient::new(env, &oft_address);
 
     // Set ZRO token in endpoint
     env.mock_auths(&[MockAuth {
@@ -59,27 +103,29 @@ fn setup_chain<'a>(env: &Env, owner: &Address) -> ChainSetup<'a> {
     register_library(env, &owner, &endpoint, &sml.address);
 
     let eid = endpoint.eid();
-    let native_token = endpoint.native_token();
-    ChainSetup { owner: owner.clone(), endpoint, sml, counter, eid, native_token }
+    ChainSetup { eid, owner, native_token, zro_token, oft_token, endpoint, sml, oft, fee_collector }
 }
 
 pub fn setup<'a>() -> TestSetup<'a> {
     let env = Env::default();
-    let owner = Address::generate(&env);
-    let sac = env.register_stellar_asset_contract_v2(owner.clone());
-    log!(&env, "native_token: {:?}", sac.address());
+    let chain_a = setup_chain(&env);
+    let chain_b = setup_chain(&env);
 
-    let chain_a = setup_chain(&env, &owner);
-    let chain_b = setup_chain(&env, &owner);
+    let chain_a_oft_token_decimals = TokenClient::new(&env, &chain_a.oft_token).decimals();
+    let chain_b_oft_token_decimals = TokenClient::new(&env, &chain_b.oft_token).decimals();
 
     log!(&env, "endpoint_a: {:?}", chain_a.endpoint.address);
     log!(&env, "native_token_a: {:?}", chain_a.native_token);
-    log!(&env, "counter_a: {:?}", chain_a.counter.address);
+    log!(&env, "oft_token_a: {:?}", chain_a.oft.token());
+    log!(&env, "oft_token_a decimals: {:?}", chain_a_oft_token_decimals);
+    log!(&env, "oft_a: {:?}", chain_a.oft.address);
     log!(&env, "sml_a: {:?}", chain_a.sml.address);
 
     log!(&env, "endpoint_b: {:?}", chain_b.endpoint.address);
     log!(&env, "native_token_b: {:?}", chain_b.native_token);
-    log!(&env, "counter_b: {:?}", chain_b.counter.address);
+    log!(&env, "oft_token_b: {:?}", chain_b.oft.token());
+    log!(&env, "oft_token_b decimals: {:?}", chain_b_oft_token_decimals);
+    log!(&env, "oft_b: {:?}", chain_b.oft.address);
     log!(&env, "sml_b: {:?}", chain_b.sml.address);
 
     TestSetup { env, chain_a, chain_b }
@@ -97,7 +143,7 @@ pub fn wire_endpoint(env: &Env, chains: &[&ChainSetup<'_>]) {
     }
 }
 
-pub fn wire_counter(env: &Env, chains: &[&ChainSetup<'_>]) {
+pub fn wire_oft(env: &Env, chains: &[&ChainSetup<'_>]) {
     for chain in chains {
         for other_chain in chains {
             if chain.endpoint.address == other_chain.endpoint.address {
@@ -106,26 +152,25 @@ pub fn wire_counter(env: &Env, chains: &[&ChainSetup<'_>]) {
             set_peer(
                 env,
                 &chain.owner,
-                &chain.counter,
+                &chain.oft,
                 other_chain.eid,
-                &address_to_bytes32(&other_chain.counter.address),
+                &address_to_peer_bytes32(&other_chain.oft.address),
             );
         }
     }
 }
 
-pub fn set_peer(env: &Env, owner: &Address, counter: &CounterClient<'_>, dst_eid: u32, peer: &BytesN<32>) {
-    let peer_option = Some(peer.clone());
+pub fn set_peer(env: &Env, owner: &Address, oft: &OFTStdClient<'_>, dst_eid: u32, peer: &BytesN<32>) {
     env.mock_auths(&[MockAuth {
         address: owner,
         invoke: &MockAuthInvoke {
-            contract: &counter.address,
+            contract: &oft.address,
             fn_name: "set_peer",
-            args: (&dst_eid, &peer_option).into_val(env),
+            args: (&dst_eid, &Some(peer.clone())).into_val(env),
             sub_invokes: &[],
         },
     }]);
-    counter.set_peer(&dst_eid, &peer_option);
+    oapp::oapp_core::OAppCoreClient::new(env, &oft.address).set_peer(&dst_eid, &Some(peer.clone()));
 }
 
 pub fn register_library(env: &Env, owner: &Address, endpoint: &EndpointV2Client<'_>, lib: &Address) {
@@ -181,6 +226,7 @@ pub fn set_default_receive_library(
 
 pub fn decode_packet(env: &Env, encoded_packet: &soroban_sdk::Bytes) -> endpoint_v2::OutboundPacket {
     use message_lib_common::packet_codec_v1::*;
+    use utils::buffer_reader::BufferReader;
 
     let header = decode_packet_header(env, &encoded_packet.slice(0..HEADER_LENGTH));
     let payload = encoded_packet.slice(HEADER_LENGTH..);
@@ -192,7 +238,7 @@ pub fn decode_packet(env: &Env, encoded_packet: &soroban_sdk::Bytes) -> endpoint
     endpoint_v2::OutboundPacket {
         nonce: header.nonce,
         src_eid: header.src_eid,
-        sender: Address::from_payload(env, AddressPayload::ContractIdHash(header.sender)),
+        sender: peer_bytes32_to_address(env, &header.sender),
         dst_eid: header.dst_eid,
         receiver: header.receiver,
         guid,

package/contracts/oapps/oft-std/integration-tests/utils.rs

@@ -0,0 +1,427 @@
+//! Utility functions for OFT-STD integration tests.
+
+use crate::integration_tests::setup::{decode_packet, ChainSetup};
+use endpoint_v2::{MessagingFee, Origin, OutboundPacket};
+use message_lib_common::packet_codec_v1;
+use oft::extensions::rate_limiter::Direction;
+use oft::types::{OFTFeeDetail, OFTLimit, OFTReceipt, SendParam};
+use soroban_sdk::{
+    address_payload::AddressPayload,
+    testutils::{Events, Ledger, MockAuth, MockAuthInvoke},
+    token::StellarAssetClient,
+    xdr::ToXdr,
+    Address, Bytes, BytesN, Env, IntoVal, Map, Symbol, Val, Vec,
+};
+
+// ============================================================================
+// Address Conversion Utilities
+// ============================================================================
+
+pub fn address_to_peer_bytes32(address: &Address) -> BytesN<32> {
+    match address.to_payload().unwrap() {
+        AddressPayload::ContractIdHash(payload) => payload,
+        AddressPayload::AccountIdPublicKeyEd25519(_) => panic!("peer must be a contract"),
+    }
+}
+
+pub fn peer_bytes32_to_address(env: &Env, bytes32: &BytesN<32>) -> Address {
+    AddressPayload::ContractIdHash(bytes32.clone()).to_address(env)
+}
+
+#[allow(dead_code)]
+pub fn create_recipient_address(env: &Env) -> Address {
+    let bytes = BytesN::from_array(env, &[0u8; 32]);
+    peer_bytes32_to_address(env, &bytes)
+}
+
+// ============================================================================
+// OFT Core Operations
+// ============================================================================
+
+pub fn quote_oft(chain: &ChainSetup<'_>, send_param: &SendParam) -> (OFTLimit, Vec<OFTFeeDetail>, OFTReceipt) {
+    chain.oft.quote_oft(send_param)
+}
+
+pub fn quote_send(
+    env: &Env,
+    chain: &ChainSetup<'_>,
+    sender: &Address,
+    send_param: &SendParam,
+    pay_in_zro: bool,
+) -> MessagingFee {
+    env.mock_auths(&[MockAuth {
+        address: sender,
+        invoke: &MockAuthInvoke {
+            contract: &chain.oft.address,
+            fn_name: "quote_send",
+            args: (sender, send_param, &pay_in_zro).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    chain.oft.quote_send(sender, send_param, &pay_in_zro)
+}
+
+/// Send without fee (standard OFT send)
+pub fn send(
+    env: &Env,
+    chain: &ChainSetup<'_>,
+    sender: &Address,
+    send_param: &SendParam,
+    fee: &MessagingFee,
+    refund_address: &Address,
+    oft_receipt: &OFTReceipt,
+) {
+    env.mock_auths(&[MockAuth {
+        address: sender,
+        invoke: &MockAuthInvoke {
+            contract: &chain.oft.address,
+            fn_name: "send",
+            args: (sender, send_param, fee, refund_address).into_val(env),
+            sub_invokes: &[
+                MockAuthInvoke {
+                    contract: &chain.native_token,
+                    fn_name: "transfer",
+                    args: (sender, &chain.endpoint.address, &fee.native_fee).into_val(env),
+                    sub_invokes: &[],
+                },
+                MockAuthInvoke {
+                    contract: &chain.oft_token,
+                    fn_name: "burn",
+                    args: (sender, &oft_receipt.amount_received_ld).into_val(env),
+                    sub_invokes: &[],
+                },
+            ],
+        },
+    }]);
+    chain.oft.send(sender, send_param, fee, refund_address);
+}
+
+/// Send with fee (OFT fee extension enabled)
+/// Order: transfer fee to deposit -> burn tokens -> transfer native fee
+pub fn send_with_fee(
+    env: &Env,
+    chain: &ChainSetup<'_>,
+    sender: &Address,
+    send_param: &SendParam,
+    fee: &MessagingFee,
+    refund_address: &Address,
+    oft_receipt: &OFTReceipt,
+    fee_deposit_address: &Address,
+) {
+    let fee_amount = oft_receipt.amount_sent_ld - oft_receipt.amount_received_ld;
+    env.mock_auths(&[MockAuth {
+        address: sender,
+        invoke: &MockAuthInvoke {
+            contract: &chain.oft.address,
+            fn_name: "send",
+            args: (sender, send_param, fee, refund_address).into_val(env),
+            sub_invokes: &[
+                MockAuthInvoke {
+                    contract: &chain.oft_token,
+                    fn_name: "transfer",
+                    args: (sender, fee_deposit_address, &fee_amount).into_val(env),
+                    sub_invokes: &[],
+                },
+                MockAuthInvoke {
+                    contract: &chain.oft_token,
+                    fn_name: "burn",
+                    args: (sender, &oft_receipt.amount_received_ld).into_val(env),
+                    sub_invokes: &[],
+                },
+                MockAuthInvoke {
+                    contract: &chain.native_token,
+                    fn_name: "transfer",
+                    args: (sender, &chain.endpoint.address, &fee.native_fee).into_val(env),
+                    sub_invokes: &[],
+                },
+            ],
+        },
+    }]);
+    chain.oft.send(sender, send_param, fee, refund_address);
+}
+
+pub fn try_send(
+    env: &Env,
+    chain: &ChainSetup<'_>,
+    sender: &Address,
+    send_param: &SendParam,
+    fee: &MessagingFee,
+    refund_address: &Address,
+    oft_receipt: &OFTReceipt,
+) -> bool {
+    env.mock_auths(&[MockAuth {
+        address: sender,
+        invoke: &MockAuthInvoke {
+            contract: &chain.oft.address,
+            fn_name: "send",
+            args: (sender, send_param, fee, refund_address).into_val(env),
+            sub_invokes: &[
+                MockAuthInvoke {
+                    contract: &chain.native_token,
+                    fn_name: "transfer",
+                    args: (sender, &chain.endpoint.address, &fee.native_fee).into_val(env),
+                    sub_invokes: &[],
+                },
+                MockAuthInvoke {
+                    contract: &chain.oft_token,
+                    fn_name: "burn",
+                    args: (sender, &oft_receipt.amount_received_ld).into_val(env),
+                    sub_invokes: &[],
+                },
+            ],
+        },
+    }]);
+    chain.oft.try_send(sender, send_param, fee, refund_address).is_ok()
+}
+
+// ============================================================================
+// Packet Handling
+// ============================================================================
+
+pub fn validate_packet(env: &Env, chain: &ChainSetup<'_>, packet_event: &(Bytes, Bytes, Address)) {
+    let packet = decode_packet(env, &packet_event.0);
+    let encoded_header = packet_codec_v1::encode_packet_header(env, &packet);
+    let payload_hash = packet_codec_v1::payload_hash(env, &packet);
+
+    env.mock_auths(&[MockAuth {
+        address: &chain.owner,
+        invoke: &MockAuthInvoke {
+            contract: &chain.sml.address,
+            fn_name: "validate_packet",
+            args: (&encoded_header, &payload_hash).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    chain.sml.validate_packet(&encoded_header, &payload_hash);
+}
+
+pub fn lz_receive(
+    env: &Env,
+    chain: &ChainSetup<'_>,
+    executor: &Address,
+    packet: &OutboundPacket,
+    recipient: &Address,
+    value: i128,
+) {
+    let origin =
+        Origin { src_eid: packet.src_eid, sender: address_to_peer_bytes32(&packet.sender), nonce: packet.nonce };
+    let extra_options = recipient.to_xdr(env);
+
+    env.mock_auths(&[MockAuth {
+        address: executor,
+        invoke: &MockAuthInvoke {
+            contract: &chain.oft.address,
+            fn_name: "lz_receive",
+            args: (executor, &origin, &packet.guid, &packet.message, &extra_options, &value).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_v2::LayerZeroReceiverClient::new(env, &chain.oft.address).lz_receive(
+        executor,
+        &origin,
+        &packet.guid,
+        &packet.message,
+        &extra_options,
+        &value,
+    );
+}
+
+pub fn try_lz_receive(
+    env: &Env,
+    chain: &ChainSetup<'_>,
+    executor: &Address,
+    packet: &OutboundPacket,
+    recipient: &Address,
+    value: i128,
+) -> bool {
+    let origin =
+        Origin { src_eid: packet.src_eid, sender: address_to_peer_bytes32(&packet.sender), nonce: packet.nonce };
+    let extra_options = recipient.to_xdr(env);
+
+    env.mock_auths(&[MockAuth {
+        address: executor,
+        invoke: &MockAuthInvoke {
+            contract: &chain.oft.address,
+            fn_name: "lz_receive",
+            args: (executor, &origin, &packet.guid, &packet.message, &extra_options, &value).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    endpoint_v2::LayerZeroReceiverClient::new(env, &chain.oft.address)
+        .try_lz_receive(executor, &origin, &packet.guid, &packet.message, &extra_options, &value)
+        .is_ok()
+}
+
+// returns (encoded_payload, options, send_library)
+pub fn scan_packet_sent_event(env: &Env, endpoint: &Address) -> Option<(Bytes, Bytes, Address)> {
+    let mut packet = None;
+    for (emitter, topics, data) in env.events().all() {
+        let packet_sent_symbol = Symbol::new(env, "packet_sent").to_val();
+        if emitter == *endpoint && topics.contains(packet_sent_symbol) {
+            let map: Map<Symbol, Val> = data.into_val(env);
+
+            let encoded_payload: Bytes = map.get(Symbol::new(env, "encoded_packet")).unwrap().into_val(env);
+            let options: Bytes = map.get(Symbol::new(env, "options")).unwrap().into_val(env);
+            let send_library: Address = map.get(Symbol::new(env, "send_library")).unwrap().into_val(env);
+
+            packet = Some((encoded_payload, options, send_library));
+        }
+    }
+
+    packet
+}
+
+// ============================================================================
+// Token Operations
+// ============================================================================
+
+pub fn mint_to(env: &Env, owner: &Address, token: &Address, to: &Address, amount: i128) {
+    env.mock_auths(&[MockAuth {
+        address: owner,
+        invoke: &MockAuthInvoke {
+            contract: token,
+            fn_name: "mint",
+            args: (to, amount).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+
+    let sac = StellarAssetClient::new(env, token);
+    sac.mint(to, &amount);
+}
+
+pub fn transfer_sac_admin(env: &Env, owner: &Address, token: &Address, new_admin: &Address) {
+    env.mock_auths(&[MockAuth {
+        address: owner,
+        invoke: &MockAuthInvoke {
+            contract: token,
+            fn_name: "set_admin",
+            args: (new_admin,).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    StellarAssetClient::new(env, token).set_admin(new_admin);
+}
+
+pub fn token_balance(env: &Env, token: &Address, account: &Address) -> i128 {
+    soroban_sdk::token::TokenClient::new(env, token).balance(account)
+}
+
+// ============================================================================
+// Pausable Extension Operations
+// ============================================================================
+
+pub fn set_paused(env: &Env, chain: &ChainSetup<'_>, paused: bool) {
+    env.mock_auths(&[MockAuth {
+        address: &chain.owner,
+        invoke: &MockAuthInvoke {
+            contract: &chain.oft.address,
+            fn_name: "set_paused",
+            args: (&paused,).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    chain.oft.set_paused(&paused);
+}
+
+pub fn is_paused(chain: &ChainSetup<'_>) -> bool {
+    chain.oft.is_paused()
+}
+
+// ============================================================================
+// OFT Fee Extension Operations
+// ============================================================================
+
+pub fn set_fee_deposit_address(env: &Env, chain: &ChainSetup<'_>, deposit_address: &Address) {
+    env.mock_auths(&[MockAuth {
+        address: &chain.owner,
+        invoke: &MockAuthInvoke {
+            contract: &chain.oft.address,
+            fn_name: "set_fee_deposit_address",
+            args: (deposit_address,).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    chain.oft.set_fee_deposit_address(deposit_address);
+}
+
+pub fn set_default_fee_bps(env: &Env, chain: &ChainSetup<'_>, fee_bps: u64) {
+    env.mock_auths(&[MockAuth {
+        address: &chain.owner,
+        invoke: &MockAuthInvoke {
+            contract: &chain.oft.address,
+            fn_name: "set_default_fee_bps",
+            args: (&fee_bps,).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    chain.oft.set_default_fee_bps(&fee_bps);
+}
+
+pub fn set_fee_bps(env: &Env, chain: &ChainSetup<'_>, dst_eid: u32, fee_bps: u64) {
+    env.mock_auths(&[MockAuth {
+        address: &chain.owner,
+        invoke: &MockAuthInvoke {
+            contract: &chain.oft.address,
+            fn_name: "set_fee_bps",
+            args: (&dst_eid, &fee_bps).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    chain.oft.set_fee_bps(&dst_eid, &fee_bps);
+}
+
+// ============================================================================
+// Rate Limiter Extension Operations
+// ============================================================================
+
+pub fn set_rate_limit(env: &Env, chain: &ChainSetup<'_>, direction: &Direction, dst_eid: u32, limit: i128, window_seconds: u64) {
+    env.mock_auths(&[MockAuth {
+        address: &chain.owner,
+        invoke: &MockAuthInvoke {
+            contract: &chain.oft.address,
+            fn_name: "set_rate_limit",
+            args: (direction, &dst_eid, &limit, &window_seconds).into_val(env),
+            sub_invokes: &[],
+        },
+    }]);
+    chain.oft.set_rate_limit(direction, &dst_eid, &limit, &window_seconds);
+}
+
+pub fn rate_limit_capacity(chain: &ChainSetup<'_>, direction: &Direction, eid: u32) -> i128 {
+    chain.oft.rate_limit_capacity(direction, &eid)
+}
+
+pub fn rate_limit_in_flight(chain: &ChainSetup<'_>, direction: &Direction, eid: u32) -> i128 {
+    chain.oft.rate_limit_in_flight(direction, &eid)
+}
+
+// ============================================================================
+// Time Utilities
+// ============================================================================
+
+pub fn advance_time(env: &Env, seconds: u64) {
+    let current = env.ledger().timestamp();
+    env.ledger().set_timestamp(current + seconds);
+}
+
+#[allow(dead_code)]
+pub fn set_timestamp(env: &Env, timestamp: u64) {
+    env.ledger().set_timestamp(timestamp);
+}
+
+// ============================================================================
+// SendParam Builder
+// ============================================================================
+
+pub fn create_send_param(env: &Env, dst_eid: u32, amount_ld: i128, min_amount_ld: i128, to: &BytesN<32>) -> SendParam {
+    SendParam {
+        dst_eid,
+        to: to.clone(),
+        amount_ld,
+        min_amount_ld,
+        extra_options: Bytes::new(env),
+        compose_msg: Bytes::new(env),
+        oft_cmd: Bytes::new(env),
+    }
+}

package/contracts/oapps/oft-std/src/lib.rs

@@ -1,5 +1,16 @@
 #![no_std]
 
-mod oft;
+pub mod oft;
+
+#[cfg(test)]
+#[path = "../integration-tests/mod.rs"]
+pub mod integration_tests;
 
 pub use oft::*;
+
+// Re-export extension types from the oft crate for convenience
+pub use ::oft::extensions::{
+    oft_fee::{OFTFee, OFTFeeError},
+    pausable::{OFTPausable, OFTPausableError},
+    rate_limiter::{Direction, RateLimit, RateLimiter, RateLimitError},
+};