@layerzerolabs/protocol-stellar-v2 0.2.20 → 0.2.22

package/contracts/oapps/oft/src/extensions/rate_limiter.rs

@@ -1,6 +1,7 @@
+use crate as oft;
 use common_macros::{contract_error, contract_trait, only_auth, storage};
-use soroban_sdk::{assert_with_error, contractevent, contracttype, panic_with_error, Env};
-use utils::ownable::Ownable;
+use soroban_sdk::{assert_with_error, contractevent, contracttype, Env};
+use utils::auth::Auth;
 
 // =========================================================================
 // Types
@@ -14,12 +15,29 @@ pub enum Direction {
     Outbound,
 }
 
+/// Configuration for rate limiting, used as input parameter.
 #[contracttype]
 #[derive(Clone, Debug, Eq, PartialEq)]
-pub struct RateLimit {
-    limit: i128,
-    window_seconds: u64,
+pub struct RateLimitConfig {
+    pub limit: i128,
+    pub window_seconds: u64,
+}
+
+/// Internal storage struct for rate limit state.
+///
+/// The rate limiter uses a "leaky bucket" algorithm where:
+/// - `config.limit` defines the maximum tokens that can be "in flight" at any time
+/// - `config.window_seconds` defines how long it takes for the bucket to fully drain
+/// - Tokens decay linearly over time: `decay = elapsed_time * limit / window_seconds`
+/// - Current in-flight = `in_flight_on_last_update - decay` (clamped to 0)
+#[contracttype]
+#[derive(Clone, Debug, Eq, PartialEq)]
+struct RateLimitState {
+    /// The rate limit configuration (limit and window_seconds)
+    config: RateLimitConfig,
+    /// The in-flight amount at the time of `last_update` (before decay is applied)
     in_flight_on_last_update: i128,
+    /// Timestamp of the last update (used to calculate decay)
     last_update: u64,
 }
 
@@ -28,8 +46,8 @@ pub struct RateLimit {
 // =========================================================================
 
 #[storage]
-pub enum RateLimitStorage {
-    #[persistent(RateLimit)]
+enum RateLimitStorage {
+    #[persistent(RateLimitState)]
     RateLimit { direction: Direction, eid: u32 },
 }
 
@@ -40,9 +58,9 @@ pub enum RateLimitStorage {
 #[contract_error]
 pub enum RateLimitError {
     ExceededRateLimit = 3120,
+    InvalidAmount,
     InvalidTimestamp,
-    InvalidWindowSeconds,
-    InvalidLimit,
+    InvalidConfig,
     SameValue,
 }
 
@@ -55,24 +73,8 @@ pub enum RateLimitError {
 pub struct RateLimitSet {
     pub direction: Direction,
     pub eid: u32,
-    pub limit: i128,
-    pub window_seconds: u64,
-}
-
-#[contractevent]
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct RateLimitUpdated {
-    pub direction: Direction,
-    pub eid: u32,
-    pub limit: i128,
-    pub window_seconds: u64,
-}
-
-#[contractevent]
-#[derive(Clone, Debug, Eq, PartialEq)]
-pub struct RateLimitUnset {
-    pub direction: Direction,
-    pub eid: u32,
+    /// The rate limit configuration, or None if the rate limit is removed
+    pub config: Option<RateLimitConfig>,
 }
 
 // =========================================================================
@@ -80,114 +82,167 @@ pub struct RateLimitUnset {
 // =========================================================================
 
 #[contract_trait]
-pub trait RateLimiter: RateLimiterInternal + Ownable + Sized {
-    #[only_auth]
-    fn set_rate_limit(env: &Env, direction: &Direction, eid: u32, limit: i128, window_seconds: u64) {
-        assert_with_error!(env, limit > 0, RateLimitError::InvalidLimit);
-        assert_with_error!(env, window_seconds > 0, RateLimitError::InvalidWindowSeconds);
-        if RateLimitStorage::has_rate_limit(env, direction, eid) {
-            let rate_limit_data = RateLimitStorage::rate_limit(env, direction, eid).unwrap();
-            assert_with_error!(
-                env,
-                limit != rate_limit_data.limit || window_seconds != rate_limit_data.window_seconds,
-                RateLimitError::SameValue
-            );
-            checkpoint_rate_limit_in_flight(env, direction, eid);
-            let mut rate_limit = RateLimitStorage::rate_limit(env, direction, eid).unwrap();
-            rate_limit.limit = limit;
-            rate_limit.window_seconds = window_seconds;
-            RateLimitStorage::set_rate_limit(env, direction, eid, &rate_limit);
-            RateLimitUpdated { direction: direction.clone(), eid, limit, window_seconds }.publish(env);
-        } else {
-            RateLimitStorage::set_rate_limit(
-                env,
-                direction,
-                eid,
-                &RateLimit {
-                    limit,
-                    window_seconds,
-                    in_flight_on_last_update: 0,
-                    last_update: env.ledger().timestamp(),
-                },
-            );
-            RateLimitSet { direction: direction.clone(), eid, limit, window_seconds }.publish(env);
-        }
-    }
+pub trait RateLimiter: RateLimiterInternal + Auth {
+    // =========================================================================
+    // Management Functions
+    // =========================================================================
 
+    /// Sets or removes a rate limit for a specific direction and endpoint.
+    ///
+    /// # Arguments
+    /// * `direction` - The direction (Inbound or Outbound)
+    /// * `eid` - The endpoint ID
+    /// * `config` - The rate limit configuration, or None to remove the rate limit
     #[only_auth]
-    fn unset_rate_limit(env: &Env, direction: &Direction, eid: u32) {
-        assert_with_error!(env, RateLimitStorage::has_rate_limit(env, direction, eid), RateLimitError::SameValue);
-        RateLimitStorage::remove_rate_limit(env, direction, eid);
-        RateLimitUnset { direction: direction.clone(), eid }.publish(env);
+    fn set_rate_limit(
+        env: &soroban_sdk::Env,
+        direction: &oft::rate_limiter::Direction,
+        eid: u32,
+        config: Option<oft::rate_limiter::RateLimitConfig>,
+    ) {
+        Self::__set_rate_limit(env, direction, eid, config);
     }
 
-    fn rate_limit_config(env: &Env, direction: &Direction, eid: u32) -> (i128, u64) {
-        if !RateLimitStorage::has_rate_limit(env, direction, eid) {
-            return (0, 0);
-        }
-        let rate_limit = RateLimitStorage::rate_limit(env, direction, eid).unwrap();
-        (rate_limit.limit, rate_limit.window_seconds)
+    // =========================================================================
+    // View Functions
+    // =========================================================================
+
+    /// Returns the rate limit configuration for a direction and endpoint.
+    /// Returns None if no rate limit is configured.
+    fn rate_limit_config(
+        env: &soroban_sdk::Env,
+        direction: &oft::rate_limiter::Direction,
+        eid: u32,
+    ) -> Option<oft::rate_limiter::RateLimitConfig> {
+        Self::__rate_limit_config(env, direction, eid)
     }
 
-    fn rate_limit_in_flight(env: &Env, direction: &Direction, eid: u32) -> i128 {
-        calculate_in_flight(env, direction, eid)
+    /// Returns the current in-flight amount for a direction and endpoint.
+    fn rate_limit_in_flight(env: &soroban_sdk::Env, direction: &oft::rate_limiter::Direction, eid: u32) -> i128 {
+        Self::__rate_limit_in_flight(env, direction, eid)
     }
 
-    fn rate_limit_capacity(env: &Env, direction: &Direction, eid: u32) -> i128 {
-        if !RateLimitStorage::has_rate_limit(env, direction, eid) {
-            return i128::MAX;
-        }
-        let rate_limit = RateLimitStorage::rate_limit(env, direction, eid).unwrap();
-        let in_flight = calculate_in_flight(env, direction, eid);
-        if rate_limit.limit > in_flight {
-            rate_limit.limit - in_flight
-        } else {
-            0
-        }
+    /// Returns the available capacity for a direction and endpoint.
+    /// Returns i128::MAX if no rate limit is configured.
+    fn rate_limit_capacity(env: &soroban_sdk::Env, direction: &oft::rate_limiter::Direction, eid: u32) -> i128 {
+        Self::__rate_limit_capacity(env, direction, eid)
     }
 }
 
 /// Internal trait for rate limiter operations used by OFT hooks.
 /// Contains only truly internal methods that are called from OFTInternal implementations.
 pub trait RateLimiterInternal {
+    // =========================================================================
+    // OFT Hooks
+    // =========================================================================
+
     /// Consumes the specified amount from the rate limit capacity.
     /// Used internally by `__debit` and `__credit` to enforce rate limits.
     ///
     /// # Errors
     /// * `ExceededRateLimit` - If the amount exceeds the available capacity.
     fn __consume_rate_limit_capacity(env: &Env, direction: &Direction, eid: u32, amount: i128) {
-        if !RateLimitStorage::has_rate_limit(env, direction, eid) {
+        assert_with_error!(env, amount >= 0, RateLimitError::InvalidAmount);
+
+        let Some(mut state) = RateLimitStorage::rate_limit(env, direction, eid) else {
             return;
-        }
-        checkpoint_rate_limit_in_flight(env, direction, eid);
-        let mut rate_limit = RateLimitStorage::rate_limit(env, direction, eid).unwrap();
-        // Check against remaining capacity (limit - current in_flight), not total limit
-        let capacity = if rate_limit.limit > rate_limit.in_flight_on_last_update {
-            rate_limit.limit - rate_limit.in_flight_on_last_update
-        } else {
-            0
         };
-        if amount > capacity {
-            panic_with_error!(env, RateLimitError::ExceededRateLimit);
-        }
-        rate_limit.in_flight_on_last_update += amount;
-        RateLimitStorage::set_rate_limit(env, direction, eid, &rate_limit);
+
+        // Apply decay and update timestamp
+        let in_flight = calculate_decayed_in_flight(env, &state);
+        state.in_flight_on_last_update = in_flight;
+        state.last_update = env.ledger().timestamp();
+
+        // Check capacity and consume
+        let capacity = (state.config.limit - in_flight).max(0);
+        assert_with_error!(env, amount <= capacity, RateLimitError::ExceededRateLimit);
+        state.in_flight_on_last_update += amount;
+
+        RateLimitStorage::set_rate_limit(env, direction, eid, &state);
     }
 
     /// Releases the specified amount back to the rate limit capacity.
     /// Used internally by `__credit` to release outbound capacity on inbound messages.
     fn __release_rate_limit_capacity(env: &Env, direction: &Direction, eid: u32, amount: i128) {
-        if !RateLimitStorage::has_rate_limit(env, direction, eid) {
+        assert_with_error!(env, amount >= 0, RateLimitError::InvalidAmount);
+
+        let Some(mut state) = RateLimitStorage::rate_limit(env, direction, eid) else {
             return;
+        };
+
+        // Apply decay and update timestamp
+        let in_flight = calculate_decayed_in_flight(env, &state);
+        state.in_flight_on_last_update = (in_flight - amount).max(0);
+        state.last_update = env.ledger().timestamp();
+
+        RateLimitStorage::set_rate_limit(env, direction, eid, &state);
+    }
+
+    // =========================================================================
+    // Management Functions
+    // =========================================================================
+
+    /// Sets or removes a rate limit for a specific direction and endpoint.
+    ///
+    /// # Arguments
+    /// * `direction` - The direction (Inbound or Outbound)
+    /// * `eid` - The endpoint ID
+    /// * `config` - The rate limit configuration, or None to remove the rate limit
+    fn __set_rate_limit(env: &Env, direction: &Direction, eid: u32, config: Option<RateLimitConfig>) {
+        let current_state = RateLimitStorage::rate_limit(env, direction, eid);
+        let current_config = current_state.as_ref().map(|s| s.config.clone());
+        assert_with_error!(env, current_config != config, RateLimitError::SameValue);
+
+        match config {
+            Some(cfg) => {
+                assert_with_error!(env, cfg.limit >= 0 && cfg.window_seconds > 0, RateLimitError::InvalidConfig);
+
+                let state = if let Some(mut existing) = current_state {
+                    // Update existing: checkpoint in-flight before changing config
+                    existing.in_flight_on_last_update = calculate_decayed_in_flight(env, &existing);
+                    existing.last_update = env.ledger().timestamp();
+                    existing.config = cfg.clone();
+                    existing
+                } else {
+                    // Create new
+                    RateLimitState {
+                        config: cfg.clone(),
+                        in_flight_on_last_update: 0,
+                        last_update: env.ledger().timestamp(),
+                    }
+                };
+
+                RateLimitStorage::set_rate_limit(env, direction, eid, &state);
+                RateLimitSet { direction: direction.clone(), eid, config: Some(cfg) }.publish(env);
+            }
+            None => {
+                RateLimitStorage::remove_rate_limit(env, direction, eid);
+                RateLimitSet { direction: direction.clone(), eid, config: None }.publish(env);
+            }
         }
-        checkpoint_rate_limit_in_flight(env, direction, eid);
-        let mut rate_limit = RateLimitStorage::rate_limit(env, direction, eid).unwrap();
-        if amount >= rate_limit.in_flight_on_last_update {
-            rate_limit.in_flight_on_last_update = 0;
-        } else {
-            rate_limit.in_flight_on_last_update -= amount;
-        }
-        RateLimitStorage::set_rate_limit(env, direction, eid, &rate_limit);
+    }
+
+    // =========================================================================
+    // View Functions
+    // =========================================================================
+
+    /// Returns the rate limit configuration for a direction and endpoint.
+    /// Returns None if no rate limit is configured.
+    fn __rate_limit_config(env: &Env, direction: &Direction, eid: u32) -> Option<RateLimitConfig> {
+        RateLimitStorage::rate_limit(env, direction, eid).map(|s| s.config)
+    }
+
+    /// Returns the current in-flight amount for a direction and endpoint.
+    fn __rate_limit_in_flight(env: &Env, direction: &Direction, eid: u32) -> i128 {
+        RateLimitStorage::rate_limit(env, direction, eid).map(|s| calculate_decayed_in_flight(env, &s)).unwrap_or(0)
+    }
+
+    /// Returns the available capacity for a direction and endpoint.
+    /// Returns i128::MAX if no rate limit is configured.
+    fn __rate_limit_capacity(env: &Env, direction: &Direction, eid: u32) -> i128 {
+        RateLimitStorage::rate_limit(env, direction, eid)
+            .map(|s| (s.config.limit - calculate_decayed_in_flight(env, &s)).max(0))
+            .unwrap_or(i128::MAX)
     }
 }
 
@@ -195,30 +250,15 @@ pub trait RateLimiterInternal {
 // Helper Functions
 // =========================================================================
 
-/// Helper function to calculate the current in-flight amount with decay.
-/// Used by both public trait methods and internal implementations.
-fn calculate_in_flight(env: &Env, direction: &Direction, eid: u32) -> i128 {
-    if !RateLimitStorage::has_rate_limit(env, direction, eid) {
-        return 0;
-    }
-    let rate_limit = RateLimitStorage::rate_limit(env, direction, eid).unwrap();
+/// Calculates the current in-flight amount with decay applied.
+/// This is a pure function that doesn't access storage.
+fn calculate_decayed_in_flight(env: &Env, state: &RateLimitState) -> i128 {
     let timestamp = env.ledger().timestamp();
-    assert_with_error!(env, timestamp >= rate_limit.last_update, RateLimitError::InvalidTimestamp);
-    let elapsed = timestamp - rate_limit.last_update;
-    let decay = (elapsed as i128) * rate_limit.limit / (rate_limit.window_seconds as i128);
-    if decay < rate_limit.in_flight_on_last_update {
-        rate_limit.in_flight_on_last_update - decay
-    } else {
-        0
-    }
-}
+    assert_with_error!(env, timestamp >= state.last_update, RateLimitError::InvalidTimestamp);
+
+    let elapsed = timestamp - state.last_update;
+    let decay = (elapsed as i128) * state.config.limit / (state.config.window_seconds as i128);
 
-/// Checkpoints the current in-flight amount by applying decay and updating timestamp.
-/// Used internally before modifying rate limit state.
-fn checkpoint_rate_limit_in_flight(env: &Env, direction: &Direction, eid: u32) {
-    let in_flight = calculate_in_flight(env, direction, eid);
-    let mut rate_limit = RateLimitStorage::rate_limit(env, direction, eid).unwrap();
-    rate_limit.in_flight_on_last_update = in_flight;
-    rate_limit.last_update = env.ledger().timestamp();
-    RateLimitStorage::set_rate_limit(env, direction, eid, &rate_limit);
+    // Ensure the decayed in-flight amount is not negative
+    (state.in_flight_on_last_update - decay).max(0)
 }

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

@@ -1,4 +1,5 @@
 use crate::{
+    self as oft,
     extensions::{
         oft_fee::{OFTFee, OFTFeeInternal},
         pausable::{OFTPausable, OFTPausableInternal},
@@ -7,7 +8,6 @@ use crate::{
     oft_types::{lock_unlock, mint_burn, OftType},
 };
 use common_macros::{contract_impl, storage};
-use endpoint_v2::Origin;
 use oapp_macros::oapp;
 use oft_core::{
     errors::OFTError,
@@ -15,7 +15,7 @@ use oft_core::{
     types::{OFTFeeDetail, OFTLimit, OFTReceipt, SendParam},
     utils as oft_utils, OFTCore, OFTInternal,
 };
-use soroban_sdk::{assert_with_error, vec, Address, Bytes, BytesN, Env, Vec};
+use soroban_sdk::{assert_with_error, vec, Address, Bytes, Env, Vec};
 
 // =========================================================================
 // Storage
@@ -83,19 +83,26 @@ impl OFTCore for OFT {
 /// OFT behavior for standard OFT with extension hooks
 impl OFTInternal for OFT {
     /// Overrides default to add pausable check and fee calculation.
+    ///
+    /// Dust handling (consistent with EVM):
+    /// - fee = 0: dust stays with sender
+    /// - fee > 0: dust goes to fee recipient (included in charged fee)
     fn __debit_view(env: &Env, amount_ld: i128, min_amount_ld: i128, dst_eid: u32) -> OFTReceipt {
         Self::__assert_not_paused(env);
 
         let conversion_rate = Self::__decimal_conversion_rate(env);
-
-        // Apply the fee before dust removal to ensure the fee is calculated on the full amount and dust is not transferred
         let fee = Self::__fee_view(env, dst_eid, amount_ld);
-        let amount_after_fee = amount_ld - fee;
-        let amount_received_ld = oft_utils::remove_dust(amount_after_fee, conversion_rate);
 
-        // amount_sent_ld = what recipient receives + fee charged
-        // Dust is excluded (stays with sender)
-        let amount_sent_ld = amount_received_ld + fee;
+        let (amount_sent_ld, amount_received_ld) = if fee == 0 {
+            // No fee: dust stays with sender (default OFT behavior)
+            let amount_sent_ld = oft_utils::remove_dust(amount_ld, conversion_rate);
+            (amount_sent_ld, amount_sent_ld)
+        } else {
+            // With fee: match EVM OFTFee behavior
+            // - dust is included in charged fee (goes to fee recipient)
+            let amount_received_ld = oft_utils::remove_dust(amount_ld - fee, conversion_rate);
+            (amount_ld, amount_received_ld)
+        };
 
         assert_with_error!(env, amount_received_ld >= min_amount_ld, OFTError::SlippageExceeded);
 
@@ -130,9 +137,9 @@ impl OFTInternal for OFT {
             OftType::MintBurn => mint_burn::credit::<Self>(env, to, amount_ld, src_eid),
         };
 
-        // 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);
+        // Rate limit checks
+        Self::__consume_rate_limit_capacity(env, &Direction::Inbound, src_eid, amount_ld);
+        Self::__release_rate_limit_capacity(env, &Direction::Outbound, src_eid, amount_ld);
 
         amount_credited
     }

package/contracts/oapps/oft/src/oft_types/lock_unlock.rs

@@ -4,7 +4,7 @@
 //! tokens from the contract on credit (receive).
 //! Used for OFT adapters that wrap existing tokens.
 
-use oft_core::{oft_core::OFTCore, types::OFTReceipt};
+use oft_core::{types::OFTReceipt, OFTCore};
 use soroban_sdk::{token::TokenClient, Address, Env};
 
 /// Debit tokens using LockUnlock OFT type (locks tokens in contract).

package/contracts/oapps/oft/src/oft_types/mint_burn.rs

@@ -3,7 +3,7 @@
 //! This OFT type burns tokens on debit (send) and mints tokens on credit (receive).
 //! Used when the OFT contract has mint/burn authority over the token.
 
-use oft_core::{oft_core::OFTCore, types::OFTReceipt};
+use oft_core::{types::OFTReceipt, OFTCore};
 use soroban_sdk::{token::StellarAssetClient, Address, Env};
 
 /// Debit tokens using MintBurn OFT type (burns tokens from sender).

package/contracts/oapps/oft-core/Cargo.toml

@@ -21,7 +21,4 @@ simple-message-lib = { workspace = true }
 message-lib-common = { workspace = true, features = ["testutils"] }
 endpoint-v2 = { workspace = true, features = ["testutils"] }
 utils = { workspace = true, features = ["testutils"] }
-insta = { workspace = true }
-oapp-macros = { workspace = true }
-stellar-macros = { workspace = true }
-stellar-tokens = { workspace = true }
+oapp-macros = { workspace = true }

package/contracts/oapps/oft-core/integration-tests/setup.rs

@@ -7,7 +7,7 @@ extern crate std;
 use crate::{
     self as oft_core,
     integration_tests::utils::{address_to_peer_bytes32, peer_bytes32_to_address},
-    oft_core::{lz_receive, OFTClient, OFTCore, OFTInternal},
+    oft_core::{OFTClient, OFTCore, OFTInternal},
     storage::OFTStorage,
     types::OFTReceipt,
 };
@@ -39,7 +39,7 @@ impl LzReceiveInternal for TestOFT {
         executor: &Address,
         value: i128,
     ) {
-        lz_receive::<Self>(env, executor, origin, guid, message, extra_data, value)
+        <Self as OFTInternal>::__receive(env, origin, guid, message, extra_data, executor, value)
     }
 }
 

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

@@ -155,10 +155,28 @@ pub fn lz_compose(
 
 // returns (encoded_payload, options, send_library)
 pub fn scan_packet_sent_event(env: &Env, endpoint: &Address) -> Option<(Bytes, Bytes, Address)> {
+    use soroban_sdk::TryFromVal;
+
     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 events = env.events().all().filter_by_contract(endpoint);
+    for event in events.events().iter() {
+        let v0 = match &event.body {
+            soroban_sdk::xdr::ContractEventBody::V0(v0) => v0,
+        };
+
+        // Check if this is a packet_sent event by looking at topics
+        let mut is_packet_sent = false;
+        for topic in v0.topics.iter() {
+            if let Ok(sym) = Symbol::try_from_val(env, topic) {
+                if sym == Symbol::new(env, "packet_sent") {
+                    is_packet_sent = true;
+                    break;
+                }
+            }
+        }
+
+        if is_packet_sent {
+            let data: Val = Val::try_from_val(env, &v0.data).unwrap();
             let map: Map<Symbol, Val> = data.into_val(env);
 
             let encoded_payload: Bytes = map.get(Symbol::new(env, "encoded_packet")).unwrap().into_val(env);

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

@@ -1,12 +1,13 @@
 use common_macros::contract_error;
 
 // OFT library error codes: 3000-3099
-// See ERROR_SPEC.md for allocation rules
+// See docs/error-spec.md for allocation rules
 
 /// OFTError: 3000-3099
 #[contract_error]
 pub enum OFTError {
-    InvalidLocalDecimals = 3000,
+    InvalidAmount = 3000,
+    InvalidLocalDecimals,
     NotInitialized,
     Overflow,
     SlippageExceeded,

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

@@ -18,3 +18,9 @@ pub struct OFTReceived {
     pub to: Address,
     pub amount_received_ld: i128,
 }
+
+#[contractevent]
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct MsgInspectorSet {
+    pub inspector: Option<Address>,
+}

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

@@ -3,7 +3,7 @@
 pub mod codec;
 pub mod errors;
 pub mod events;
-pub mod oft_core;
+mod oft_core;
 pub mod storage;
 pub mod types;
 pub mod utils;