@layerzerolabs/protocol-stellar-v2 0.2.8

package/contracts/utils/src/ttl.rs

@@ -0,0 +1,164 @@
+use crate as utils;
+use crate::errors::TtlError;
+use soroban_sdk::{assert_with_error, contracttype, Env};
+
+/// Number of ledgers per day (~5 second ledger close time).
+pub const LEDGERS_PER_DAY: u32 = (24 * 3600) / 5;
+
+/// Maximum TTL (1 year) allowed by the protocol.
+/// Note: Stellar's current maximum TTL is 6 months, but this constraint may change
+/// in the future. In order to preserve LayerZero's censorship-resistance and protect
+/// users from abusive parameter changes, a constant upper bound is enforced on the
+/// extend_to value.
+pub const MAX_TTL: u32 = 365 * LEDGERS_PER_DAY;
+
+/// Default TTL for instance storage (30 days, extends at 29 days remaining).
+pub const DEFAULT_INSTANCE_TTL: TtlConfig = TtlConfig::new(29 * LEDGERS_PER_DAY, 30 * LEDGERS_PER_DAY);
+/// Default TTL for persistent storage (30 days, extends at 29 days remaining).
+pub const DEFAULT_PERSISTENT_TTL: TtlConfig = TtlConfig::new(29 * LEDGERS_PER_DAY, 30 * LEDGERS_PER_DAY);
+/// Default TTL for temporary storage (7 days, extends at 6 days remaining).
+pub const DEFAULT_TEMPORARY_TTL: TtlConfig = TtlConfig::new(6 * LEDGERS_PER_DAY, 7 * LEDGERS_PER_DAY);
+
+/// A pair of TTL values: threshold (when to trigger extension) and extend_to (target TTL).
+#[contracttype]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct TtlConfig {
+    /// TTL threshold that triggers extension (in ledgers).
+    pub threshold: u32,
+    /// Target TTL after extension (in ledgers).
+    pub extend_to: u32,
+}
+
+impl TtlConfig {
+    /// Creates a new TTL config.
+    pub const fn new(threshold: u32, extend_to: u32) -> Self {
+        Self { threshold, extend_to }
+    }
+
+    /// Validates that threshold <= extend_to <= max_ttl.
+    pub fn is_valid(&self, max_ttl: u32) -> bool {
+        self.threshold <= self.extend_to && self.extend_to <= max_ttl
+    }
+}
+
+/// Storage keys for TTL configuration.
+#[common_macros::storage]
+pub enum TtlConfigData {
+    #[instance(bool)]
+    #[default(false)]
+    Frozen,
+
+    #[instance(TtlConfig)]
+    Instance,
+
+    #[instance(TtlConfig)]
+    Persistent,
+
+    #[instance(TtlConfig)]
+    Temporary,
+}
+
+/// Trait for providing TTL configurations.
+pub trait TtlConfigProvider {
+    fn persistent(env: &Env) -> TtlConfig;
+    fn instance(env: &Env) -> TtlConfig;
+    fn temporary(env: &Env) -> TtlConfig;
+}
+
+/// Helper functions used by the `#[storage]` macro to enforce that a user-provided
+/// TTL config provider implements the [`TtlConfigProvider`] trait.
+///
+/// The macro generates code that calls these functions with the provider type as
+/// the generic parameter `T`. If the provider does not implement `TtlConfigProvider`,
+/// the compiler will emit an error at the macro expansion site, ensuring type safety
+/// at compile time.
+pub mod ttl_config {
+    use super::{TtlConfig, TtlConfigProvider};
+    use soroban_sdk::Env;
+
+    pub fn instance<T: TtlConfigProvider>(env: &Env) -> TtlConfig {
+        T::instance(env)
+    }
+
+    pub fn persistent<T: TtlConfigProvider>(env: &Env) -> TtlConfig {
+        T::persistent(env)
+    }
+
+    pub fn temporary<T: TtlConfigProvider>(env: &Env) -> TtlConfig {
+        T::temporary(env)
+    }
+}
+
+/// Default implementation using TtlConfigData storage.
+pub struct DefaultTtlConfigProvider;
+
+impl TtlConfigProvider for DefaultTtlConfigProvider {
+    fn instance(env: &Env) -> TtlConfig {
+        TtlConfigData::instance(env).unwrap_or(DEFAULT_INSTANCE_TTL)
+    }
+
+    fn persistent(env: &Env) -> TtlConfig {
+        TtlConfigData::persistent(env).unwrap_or(DEFAULT_PERSISTENT_TTL)
+    }
+
+    fn temporary(env: &Env) -> TtlConfig {
+        TtlConfigData::temporary(env).unwrap_or(DEFAULT_TEMPORARY_TTL)
+    }
+}
+
+/// Trait for contracts that allow TTL configuration management.
+pub trait TtlConfigurable {
+    /// Sets TTL configs. None values remove the config (use defaults).
+    fn set_ttl_config(
+        env: &Env,
+        instance: &Option<TtlConfig>,
+        persistent: &Option<TtlConfig>,
+        temporary: &Option<TtlConfig>,
+    );
+
+    /// Returns current TTL configs (instance, persistent, temporary).
+    fn ttl_config(env: &Env) -> (Option<TtlConfig>, Option<TtlConfig>, Option<TtlConfig>);
+
+    /// Permanently freezes TTL config, preventing further changes.
+    fn freeze_ttl_config(env: &Env);
+
+    /// Returns whether TTL config is frozen.
+    fn is_ttl_config_frozen(env: &Env) -> bool;
+}
+
+/// Default implementation of TtlConfigurable.
+pub struct DefaultTtlConfigurable;
+
+impl TtlConfigurable for DefaultTtlConfigurable {
+    fn set_ttl_config(
+        env: &Env,
+        instance: &Option<TtlConfig>,
+        persistent: &Option<TtlConfig>,
+        temporary: &Option<TtlConfig>,
+    ) {
+        assert_with_error!(env, !Self::is_ttl_config_frozen(env), TtlError::TtlConfigFrozen);
+
+        let max_ttl = u32::min(MAX_TTL, env.storage().max_ttl());
+        let all_valid = [instance, persistent, temporary].iter().all(|c| c.is_none_or(|cfg| cfg.is_valid(max_ttl)));
+        assert_with_error!(env, all_valid, TtlError::InvalidTtlConfig);
+
+        TtlConfigData::set_or_remove_instance(env, instance);
+        TtlConfigData::set_or_remove_persistent(env, persistent);
+        TtlConfigData::set_or_remove_temporary(env, temporary);
+    }
+
+    fn ttl_config(env: &Env) -> (Option<TtlConfig>, Option<TtlConfig>, Option<TtlConfig>) {
+        (TtlConfigData::instance(env), TtlConfigData::persistent(env), TtlConfigData::temporary(env))
+    }
+
+    fn freeze_ttl_config(env: &Env) {
+        assert_with_error!(env, !Self::is_ttl_config_frozen(env), TtlError::TtlConfigAlreadyFrozen);
+        TtlConfigData::set_frozen(env, &true);
+    }
+
+    fn is_ttl_config_frozen(env: &Env) -> bool {
+        TtlConfigData::frozen(env)
+    }
+}
+
+// TODO: add events

package/contracts/workers/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "workers"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+publish = false
+
+[lib]
+path = "lib.rs"
+
+[dependencies]
+
+

package/contracts/workers/executor/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "executor"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+publish = false
+
+[lib]
+crate-type = ["cdylib"]
+doctest = false
+
+[dependencies]
+soroban-sdk = { workspace = true }
+endpoint-v2 = { workspace = true, features = ["library"] }
+utils = { workspace = true }
+worker-common = { workspace = true }
+stellar-access = { workspace = true }
+stellar-macros = { workspace = true }
+stellar-contract-utils = { workspace = true }
+common-macros = { workspace = true }
+message-lib-common = { workspace = true }
+
+[dev-dependencies]
+soroban-sdk = { workspace = true, features = ["testutils"] }
+message-lib-common = { workspace = true, features = ["testutils"] }
+

package/contracts/workers/executor/src/events.rs

@@ -0,0 +1,22 @@
+use endpoint_v2::Origin;
+use soroban_sdk::{contractevent, Address, Vec};
+
+use crate::interfaces::{NativeDropParams, SetDstConfigParam};
+
+// === Executor Events ===
+
+#[contractevent(topics = ["DstConfigSet"])]
+#[derive(Clone, Eq, PartialEq)]
+pub struct DstConfigSet {
+    pub params: Vec<SetDstConfigParam>,
+}
+
+#[contractevent(topics = ["NativeDropApplied"])]
+#[derive(Clone, Eq, PartialEq)]
+pub struct NativeDropApplied {
+    pub origin: Origin,
+    pub dst_eid: u32,
+    pub oapp: Address,
+    pub native_drop_params: Vec<NativeDropParams>,
+    pub success: Vec<bool>,
+}

package/contracts/workers/executor/src/executor.rs

@@ -0,0 +1,347 @@
+use crate::{
+    events::{DstConfigSet, NativeDropApplied},
+    interfaces::{DstConfig, ExecutionParams, IExecutor, NativeDropParams, SetDstConfigParam},
+    storage::ExecutorData,
+    ComposeParams,
+};
+use endpoint_v2::{
+    FeeRecipient, LayerZeroComposerClient, LayerZeroEndpointV2Client, LayerZeroReceiverClient, MessagingComposerClient,
+};
+use message_lib_common::ILayerZeroExecutor;
+use soroban_sdk::{assert_with_error, bytes, contract, contractimpl, token, vec, Address, Bytes, Env, Vec};
+use stellar_access::access_control::AccessControl;
+use stellar_macros::{default_impl, only_role, when_not_paused};
+use worker_common::{ExecutorFeeLibClient, FeeParams, IWorker, WorkerCommon, WorkerError};
+
+// ============================================================================
+// Executor Contract
+// ============================================================================
+
+#[contract]
+pub struct LzExecutor;
+
+// ============================================================================
+// Constructor
+// ============================================================================
+
+#[contractimpl()]
+impl LzExecutor {
+    /// Constructor - Initialize the executor contract
+    /// Follows the EVM pattern: initialize(endpoint, messageLibs, priceFeed, roleAdmin, admins)
+    pub fn __constructor(
+        env: &Env,
+        endpoint: &Address,
+        message_libs: &Vec<Address>,
+        price_feed: &Address,
+        default_multiplier_bps: u32,
+        role_admin: &Address,
+        admins: &Vec<Address>,
+    ) {
+        // Initialize WorkerCommon (handles access control and basic worker setup)
+        WorkerCommon::initialize(env, role_admin, message_libs, price_feed, default_multiplier_bps, admins);
+
+        // Store executor-specific data
+        ExecutorData::set_endpoint(env, endpoint);
+
+        // Get and store the local EID from the endpoint
+        let endpoint_client = LayerZeroEndpointV2Client::new(env, endpoint);
+        let local_eid = endpoint_client.eid();
+        ExecutorData::set_local_eid(env, &local_eid);
+    }
+
+    pub(crate) fn endpoint(env: &Env) -> Address {
+        ExecutorData::endpoint(env).unwrap()
+    }
+}
+
+// ============================================================================
+// IWorker Implementation (delegate to WorkerCommon)
+// ============================================================================
+
+#[contractimpl]
+impl IWorker for LzExecutor {
+    // ========================================================================
+    // Mutable Functions
+    // ========================================================================
+
+    fn set_paused(env: &Env, paused: bool) {
+        WorkerCommon::set_paused(env, paused);
+    }
+
+    fn set_default_multiplier_bps(env: &Env, admin: &Address, multiplier_bps: u32) {
+        WorkerCommon::set_default_multiplier_bps(env, admin, multiplier_bps);
+    }
+
+    fn set_deposit_address(env: &Env, admin: &Address, deposit_address: &Address) {
+        WorkerCommon::set_deposit_address(env, admin, deposit_address);
+    }
+
+    fn set_price_feed(env: &Env, admin: &Address, price_feed: &Address) {
+        WorkerCommon::set_price_feed(env, admin, price_feed);
+    }
+
+    fn set_supported_option_types(env: &Env, admin: &Address, eid: u32, option_types: Bytes) {
+        WorkerCommon::set_supported_option_types(env, admin, eid, option_types);
+    }
+
+    fn set_worker_fee_lib(env: &Env, admin: &Address, worker_fee_lib: &Address) {
+        WorkerCommon::set_worker_fee_lib(env, admin, worker_fee_lib);
+    }
+
+    // ========================================================================
+    // View Functions
+    // ========================================================================
+
+    fn paused(env: &Env) -> bool {
+        WorkerCommon::paused(env)
+    }
+
+    fn default_multiplier_bps(env: &Env) -> u32 {
+        WorkerCommon::default_multiplier_bps(env)
+    }
+
+    fn deposit_address(env: &Env) -> Address {
+        WorkerCommon::deposit_address(env)
+    }
+
+    fn price_feed(env: &Env) -> Address {
+        WorkerCommon::price_feed(env)
+    }
+
+    fn get_supported_option_types(env: &Env, eid: u32) -> Bytes {
+        WorkerCommon::get_supported_option_types(env, eid)
+    }
+
+    fn worker_fee_lib(env: &Env) -> Address {
+        WorkerCommon::worker_fee_lib(env)
+    }
+
+    fn has_acl(env: &Env, sender: &Address) -> bool {
+        WorkerCommon::has_acl(env, sender)
+    }
+
+    fn allowlist_size(env: &Env) -> u32 {
+        WorkerCommon::allowlist_size(env)
+    }
+}
+
+// ============================================================================
+// IExecutor Implementation
+// ============================================================================
+
+#[contractimpl]
+impl IExecutor for LzExecutor {
+    // === Destination Configuration ===
+
+    #[only_role(admin, "ADMIN")]
+    fn set_dst_config(env: &Env, admin: &Address, params: &Vec<SetDstConfigParam>) {
+        for param in params.iter() {
+            ExecutorData::set_dst_config(env, param.dst_eid, &param.dst_config);
+        }
+        DstConfigSet { params: params.clone() }.publish(env);
+    }
+
+    // === Execution Functions ===
+
+    #[only_role(admin, "ADMIN")]
+    fn native_drop(
+        env: &Env,
+        admin: &Address,
+        origin: &endpoint_v2::Origin,
+        dst_eid: u32,
+        oapp: &Address,
+        native_drop_params: &Vec<NativeDropParams>,
+    ) {
+        let endpoint = Self::endpoint(env);
+        let native_token_client =
+            token::TokenClient::new(env, &LayerZeroEndpointV2Client::new(env, &endpoint).native_token());
+
+        let mut success = vec![env];
+
+        for param in native_drop_params.iter() {
+            // Attempt to transfer native tokens to the receiver
+            // In Stellar, we use the token client to transfer
+            let transfer_success = native_token_client
+                .try_transfer(&env.current_contract_address(), &param.receiver, &param.amount)
+                .is_ok();
+
+            success.push_back(transfer_success);
+        }
+
+        NativeDropApplied {
+            origin: origin.clone(),
+            dst_eid,
+            oapp: oapp.clone(),
+            native_drop_params: native_drop_params.clone(),
+            success,
+        }
+        .publish(env);
+    }
+
+    #[only_role(admin, "ADMIN")]
+    fn execute(env: &Env, admin: &Address, execution_params: &ExecutionParams) {
+        let endpoint = Self::endpoint(env);
+        let endpoint_client = LayerZeroEndpointV2Client::new(env, &endpoint);
+        let native_token_client = token::TokenClient::new(env, &endpoint_client.native_token());
+
+        // Transfer value to receiver if needed (matching EVM pattern)
+        if execution_params.value > 0 {
+            native_token_client.transfer(admin, env.current_contract_address(), &execution_params.value);
+        }
+
+        // Call lz_receive on the receiver
+        let receiver_client = LayerZeroReceiverClient::new(env, &execution_params.receiver);
+
+        // Try to execute lz_receive (matching EVM try-catch pattern)
+        let result = receiver_client.try_lz_receive(
+            &env.current_contract_address(),
+            &execution_params.origin,
+            &execution_params.guid,
+            &execution_params.message,
+            &execution_params.extra_data,
+            &execution_params.value,
+        );
+
+        // If execution failed, call lz_receive_alert on endpoint (matching EVM catch block)
+        if result.is_err() {
+            // Get the error reason - in Stellar we just use an empty bytes for simplicity
+            let reason = bytes![env];
+            endpoint_client.lz_receive_alert(
+                &env.current_contract_address(),
+                &execution_params.origin,
+                &execution_params.receiver,
+                &execution_params.guid,
+                &execution_params.gas_limit,
+                &execution_params.value,
+                &execution_params.message,
+                &execution_params.extra_data,
+                &reason,
+            );
+        }
+    }
+
+    #[only_role(admin, "ADMIN")]
+    fn compose(env: &Env, admin: &Address, compose_params: &ComposeParams) {
+        let endpoint = ExecutorData::endpoint(env).expect("endpoint not set");
+        let endpoint_client = LayerZeroEndpointV2Client::new(env, &endpoint);
+        let native_token_client = token::TokenClient::new(env, &endpoint_client.native_token());
+
+        // Transfer value to composer if needed (matching EVM pattern)
+        if compose_params.value > 0 {
+            native_token_client.transfer(admin, env.current_contract_address(), &compose_params.value);
+        }
+
+        // Call lz_compose on the composer
+        let composer_client = LayerZeroComposerClient::new(env, &compose_params.to);
+
+        // Try to execute lz_compose (matching EVM try-catch pattern)
+        let result = composer_client.try_lz_compose(
+            &env.current_contract_address(),
+            &compose_params.from,
+            &compose_params.guid,
+            &compose_params.index,
+            &compose_params.message,
+            &compose_params.extra_data,
+            &compose_params.value,
+        );
+
+        // If execution failed, call lz_compose_alert on endpoint (matching EVM catch block)
+        if result.is_err() {
+            // Get the error reason - in Stellar we just use an empty bytes for simplicity
+            let reason = bytes![env];
+
+            // lz_compose_alert is on MessagingComposerClient, not LayerZeroEndpointV2Client
+            let composer_client = MessagingComposerClient::new(env, &endpoint);
+            composer_client.lz_compose_alert(
+                &env.current_contract_address(),
+                &compose_params.from,
+                &compose_params.to,
+                &compose_params.guid,
+                &compose_params.index,
+                &compose_params.gas_limit,
+                &compose_params.value,
+                &compose_params.message,
+                &compose_params.extra_data,
+                &reason,
+            );
+        }
+    }
+
+    // View Functions
+
+    fn dst_config(env: &Env, dst_eid: u32) -> Option<DstConfig> {
+        ExecutorData::dst_config(env, dst_eid)
+    }
+}
+
+// ============================================================================
+// IMsgLibExecutor Implementation (for message libraries)
+// ============================================================================
+
+#[contractimpl]
+impl ILayerZeroExecutor for LzExecutor {
+    #[only_role(_send_lib, "MSG_LIB")]
+    #[when_not_paused()]
+    fn assign_job(
+        env: &Env,
+        _send_lib: &Address,
+        sender: &Address,
+        dst_eid: u32,
+        calldata_size: u32,
+        options: &Bytes,
+    ) -> FeeRecipient {
+        let fee = Self::get_fee(env, _send_lib, sender, dst_eid, calldata_size, options);
+        let recipient = WorkerCommon::deposit_address(env);
+        FeeRecipient { amount: fee, address: recipient }
+    }
+
+    #[when_not_paused()]
+    fn get_fee(
+        env: &Env,
+        _send_lib: &Address,
+        sender: &Address,
+        dst_eid: u32,
+        calldata_size: u32,
+        options: &Bytes,
+    ) -> i128 {
+        // Check ACL
+        assert_with_error!(env, WorkerCommon::has_acl(env, sender), WorkerError::NotAllowed);
+
+        // Get the dst_config
+        let dst_config = Self::dst_config(env, dst_eid).unwrap_or(DstConfig {
+            lz_receive_base_gas: 0,
+            multiplier_bps: 0,
+            floor_margin_usd: 0,
+            native_cap: 0,
+            lz_compose_base_gas: 0,
+        });
+
+        // Build FeeParams for the executor fee lib
+        let fee_params = FeeParams {
+            sender: sender.clone(),
+            dst_eid,
+            calldata_size,
+            options: options.clone(),
+            price_feed: WorkerCommon::price_feed(env),
+            default_multiplier_bps: WorkerCommon::default_multiplier_bps(env),
+            lz_receive_base_gas: dst_config.lz_receive_base_gas,
+            lz_compose_base_gas: dst_config.lz_compose_base_gas,
+            floor_margin_usd: dst_config.floor_margin_usd,
+            native_cap: dst_config.native_cap,
+            multiplier_bps: dst_config.multiplier_bps,
+        };
+
+        // Call the executor fee lib to get the fee
+        let fee_lib = WorkerCommon::worker_fee_lib(env);
+        let fee_lib_client = ExecutorFeeLibClient::new(env, &fee_lib);
+        fee_lib_client.get_fee(&fee_lib, &fee_params)
+    }
+}
+
+// ============================================================================
+// AccessControl Implementation (default from stellar-access)
+// ============================================================================
+
+#[default_impl]
+#[contractimpl]
+impl AccessControl for LzExecutor {}

package/contracts/workers/executor/src/interfaces/executor.rs

@@ -0,0 +1,40 @@
+use endpoint_v2::Origin;
+use message_lib_common::ILayerZeroExecutor;
+use soroban_sdk::{contractclient, Address, Env, Vec};
+use worker_common::IWorker;
+
+use crate::{
+    interfaces::{DstConfig, ExecutionParams, NativeDropParams, SetDstConfigParam},
+    ComposeParams,
+};
+
+/// IExecutor - Main executor interface that combines multiple executor capabilities
+/// Inherits from: IWorker and includes LayerZero execution methods
+#[contractclient(name = "ExecutorClient")]
+pub trait IExecutor: IWorker + ILayerZeroExecutor {
+    // === Destination Configuration ===
+
+    /// Get destination configuration for a specific endpoint
+    fn dst_config(env: &Env, dst_eid: u32) -> Option<DstConfig>;
+
+    /// Set destination configurations (admin only)
+    fn set_dst_config(env: &Env, admin: &Address, params: &Vec<SetDstConfigParam>);
+
+    // === Execution Functions ===
+
+    /// Execute native token drops
+    fn native_drop(
+        env: &Env,
+        admin: &Address,
+        origin: &Origin,
+        dst_eid: u32,
+        oapp: &Address,
+        native_drop_params: &Vec<NativeDropParams>,
+    );
+
+    /// Execute v2 message
+    fn execute(env: &Env, admin: &Address, execution_params: &ExecutionParams);
+
+    /// Compose v2 message
+    fn compose(env: &Env, admin: &Address, compose_params: &ComposeParams);
+}

package/contracts/workers/executor/src/interfaces/mod.rs

@@ -0,0 +1,5 @@
+pub mod executor;
+pub mod types;
+
+pub use executor::*;
+pub use types::*;

package/contracts/workers/executor/src/interfaces/types.rs

@@ -0,0 +1,51 @@
+use endpoint_v2::Origin;
+use soroban_sdk::{contracttype, Address, Bytes, BytesN};
+
+#[contracttype]
+#[derive(Clone, Debug)]
+pub struct DstConfig {
+    pub lz_receive_base_gas: u64,
+    pub multiplier_bps: u32,
+    pub floor_margin_usd: u128,
+    pub native_cap: u128,
+    pub lz_compose_base_gas: u64,
+}
+
+#[contracttype]
+#[derive(Clone, Debug)]
+pub struct SetDstConfigParam {
+    pub dst_eid: u32,
+    pub dst_config: DstConfig,
+}
+
+#[contracttype]
+#[derive(Clone, Debug)]
+pub struct ExecutionParams {
+    pub receiver: Address,
+    pub origin: Origin,
+    pub guid: BytesN<32>,
+    pub message: Bytes,
+    pub extra_data: Bytes,
+    pub value: i128,
+    pub gas_limit: i128,
+}
+
+#[contracttype]
+#[derive(Clone, Debug)]
+pub struct NativeDropParams {
+    pub receiver: Address,
+    pub amount: i128,
+}
+
+#[contracttype]
+#[derive(Clone, Debug)]
+pub struct ComposeParams {
+    pub from: Address,
+    pub to: Address,
+    pub guid: BytesN<32>,
+    pub index: u32,
+    pub message: Bytes,
+    pub extra_data: Bytes,
+    pub value: i128,
+    pub gas_limit: i128,
+}

package/contracts/workers/executor/src/lib.rs

@@ -0,0 +1,10 @@
+#![no_std]
+
+pub mod events;
+pub mod executor;
+pub mod interfaces;
+pub mod storage;
+
+pub use events::*;
+pub use executor::*;
+pub use interfaces::*;