@layerzerolabs/protocol-stellar-v2 0.2.18 → 0.2.20

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

@@ -1,427 +0,0 @@
-//! 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,16 +0,0 @@
-#![no_std]
-
-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},
-};

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

@@ -1,174 +0,0 @@
-use common_macros::{contract_impl, storage};
-use endpoint_v2::Origin;
-use oapp::oapp_receiver::LzReceiveInternal;
-use oapp_macros::oapp;
-use oft::{
-    errors::OFTError,
-    extensions::{
-        oft_fee::{OFTFee, OFTFeeInternal},
-        pausable::{OFTPausable, OFTPausableInternal},
-        rate_limiter::{Direction, RateLimiter, RateLimiterInternal},
-    },
-    initialize_oft,
-    oft::{OFTInternal, OFT},
-    oft_impl,
-    oft_types::{lock_unlock, mint_burn},
-    storage::OFTStorage,
-    types::{OFTFeeDetail, OFTLimit, OFTReceipt, SendParam},
-    utils::remove_dust,
-};
-use soroban_sdk::{assert_with_error, contracttype, Address, Bytes, BytesN, Env, Vec};
-
-/// The mode of operation for the OFT contract
-#[contracttype]
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-#[repr(u8)]
-pub enum OFTMode {
-    /// Lock tokens on send, unlock on receive
-    LockUnlock = 0,
-    /// Burn tokens on send, mint on receive
-    MintBurn = 1,
-}
-
-#[storage]
-enum OFTStdStorage {
-    #[instance(OFTMode)]
-    Mode,
-}
-
-#[oapp]
-pub struct OFTStd;
-
-#[contract_impl]
-impl OFTStd {
-    pub fn __constructor(
-        env: &Env,
-        token: &Address,
-        owner: &Address,
-        endpoint: &Address,
-        delegate: &Option<Address>,
-        shared_decimals: u32,
-        mode: OFTMode,
-    ) {
-        initialize_oft::<Self>(env, owner, token, endpoint, delegate, shared_decimals);
-        OFTStdStorage::set_mode(env, &mode);
-    }
-
-    /// Returns the mode of operation for this OFT (LockUnlock or MintBurn)
-    pub fn mode(env: &Env) -> OFTMode {
-        OFTStdStorage::mode(env).unwrap()
-    }
-}
-
-/// LzReceiveInternal implementation using default OFT receive logic
-impl LzReceiveInternal for OFTStd {
-    fn __lz_receive(
-        env: &Env,
-        origin: &Origin,
-        guid: &BytesN<32>,
-        message: &Bytes,
-        extra_data: &Bytes,
-        executor: &Address,
-        value: i128,
-    ) {
-        oft_impl::lz_receive::<Self>(env, executor, origin, guid, message, extra_data, value)
-    }
-}
-
-/// OFT trait implementation for standard OFT with extensions
-#[contract_impl(contracttrait)]
-impl OFT for OFTStd {
-    fn quote_oft(env: &Env, send_param: &SendParam) -> (OFTLimit, Vec<OFTFeeDetail>, OFTReceipt) {
-        Self::__assert_not_paused(env);
-        let (_, fee_details, oft_receipt) = oft_impl::quote_oft::<Self>(env, send_param);
-        let capacity = Self::rate_limit_capacity(env, &Direction::Outbound, send_param.dst_eid);
-        let oft_limit = OFTLimit { min_amount_ld: 0, max_amount_ld: capacity };
-        (oft_limit, fee_details, oft_receipt)
-    }
-
-    fn quote_send(env: &Env, sender: &Address, send_param: &SendParam, pay_in_zro: bool) -> endpoint_v2::MessagingFee {
-        Self::__assert_not_paused(env);
-        oft_impl::quote_send::<Self>(env, sender, send_param, pay_in_zro)
-    }
-}
-
-/// OFT behavior for standard OFT with extension hooks
-impl OFTInternal for OFTStd {
-    fn __debit(env: &Env, sender: &Address, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
-        // 1. Pausable check
-        Self::__assert_not_paused(env);
-
-        // 2. Core debit logic (based on mode)
-        let oft_receipt = match Self::mode(env) {
-            OFTMode::LockUnlock => lock_unlock::debit::<Self>(env, sender, amount_ld, min_amount_ld, dst_eid),
-            OFTMode::MintBurn => mint_burn::debit::<Self>(env, sender, amount_ld, min_amount_ld, dst_eid),
-        };
-
-        // 3. Rate limit checks (using amount_received_ld - the actual cross-chain amount)
-        Self::__consume_rate_limit_capacity(env, &Direction::Outbound, dst_eid, oft_receipt.amount_received_ld);
-        Self::__release_rate_limit_capacity(env, &Direction::Inbound, dst_eid, oft_receipt.amount_received_ld);
-
-        // 4. Charge fee (amount_sent_ld - amount_received_ld)
-        Self::__charge_fee(env, &Self::token(env), sender, oft_receipt.amount_sent_ld - oft_receipt.amount_received_ld);
-
-        oft_receipt
-    }
-
-    fn __credit(env: &Env, to: &Address, amount_ld: i128, src_eid: u32) -> i128 {
-        // 1. Pausable check
-        Self::__assert_not_paused(env);
-
-        // 2. Core credit logic (based on mode)
-        let amount_credited = match Self::mode(env) {
-            OFTMode::LockUnlock => lock_unlock::credit::<Self>(env, to, amount_ld, src_eid),
-            OFTMode::MintBurn => mint_burn::credit::<Self>(env, to, amount_ld, src_eid),
-        };
-
-        // 3. Rate limit checks (using amount_credited - the actual credited amount)
-        Self::__consume_rate_limit_capacity(env, &Direction::Inbound, src_eid, amount_credited);
-        Self::__release_rate_limit_capacity(env, &Direction::Outbound, src_eid, amount_credited);
-
-        amount_credited
-    }
-
-    fn __debit_view(env: &Env, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
-        let conversion_rate = OFTStorage::decimal_conversion_rate(env).unwrap();
-
-        // CRITICAL: Apply fee first, then remove dust
-        let amount_after_fee = Self::__fee_view(env, dst_eid, amount_ld);
-        let amount_received_ld = remove_dust(amount_after_fee, conversion_rate);
-
-        // amount_sent_ld logic:
-        // - If no fee: amount_sent_ld = amount_received_ld (both reduced by dust)
-        // - If fee applied: amount_sent_ld = original amount_ld (unchanged)
-        // This is to align the behavior with the fee extensions on other VMs
-        let amount_sent_ld = if amount_after_fee == amount_ld { amount_received_ld } else { amount_ld };
-
-        assert_with_error!(env, amount_received_ld >= min_amount_ld, OFTError::SlippageExceeded);
-
-        OFTReceipt { amount_sent_ld, amount_received_ld }
-    }
-}
-
-// ==================== Extension Trait Implementations ====================
-
-/// Pausable extension - allows pausing/unpausing the OFT
-/// Default state: unpaused (all operations allowed)
-#[contract_impl(contracttrait)]
-impl OFTPausable for OFTStd {}
-
-impl OFTPausableInternal for OFTStd {}
-
-/// OFT Fee extension - allows collecting fees on transfers
-/// Default state: 0 BPS (no fee collected)
-#[contract_impl(contracttrait)]
-impl OFTFee for OFTStd {}
-
-impl OFTFeeInternal for OFTStd {}
-
-/// Rate Limiter extension - allows rate limiting transfers
-/// Default state: not set (rate_limit_capacity returns i128::MAX)
-#[contract_impl(contracttrait)]
-impl RateLimiter for OFTStd {}
-
-impl RateLimiterInternal for OFTStd {}