@layerzerolabs/protocol-starknet-v2 0.0.34

package/layerzero/src/oapps/common/oapp_options_type_3/errors.cairo

@@ -0,0 +1,22 @@
+use lz_utils::error::{Error, format_error};
+
+#[derive(Drop)]
+pub enum OAppOptionsType3Error {
+    InvalidOptions,
+}
+
+impl ErrorNameImpl of Error<OAppOptionsType3Error> {
+    fn prefix() -> ByteArray {
+        "LZ_OAPP_OPTIONS_TYPE3"
+    }
+
+    fn name(self: OAppOptionsType3Error) -> ByteArray {
+        match self {
+            OAppOptionsType3Error::InvalidOptions => "INVALID_OPTIONS",
+        }
+    }
+}
+
+pub fn err_invalid_options(options: @ByteArray) -> ByteArray {
+    format_error(OAppOptionsType3Error::InvalidOptions, format!("options_len: {}", options.len()))
+}

package/layerzero/src/oapps/common/oapp_options_type_3/events.cairo

@@ -0,0 +1,6 @@
+use crate::oapps::common::oapp_options_type_3::structs::EnforcedOptionParam;
+
+#[derive(Drop, starknet::Event)]
+pub struct EnforcedOptionSet {
+    pub options: Array<EnforcedOptionParam>,
+}

package/layerzero/src/oapps/common/oapp_options_type_3/interface.cairo

@@ -0,0 +1,34 @@
+use crate::oapps::common::oapp_options_type_3::structs::EnforcedOptionParam;
+
+#[starknet::interface]
+pub trait IOAppOptionsType3<TContractState> {
+    /// Sets the enforced options for specific endpoint and message type combinations.
+    /// Only the owner/admin of the OApp can call this function.
+    ///
+    /// # Arguments
+    /// * `enforced_options` - Array of EnforcedOptionParam structures specifying enforced options
+    fn set_enforced_options(ref self: TContractState, enforced_options: Array<EnforcedOptionParam>);
+
+    /// Combines options for a given endpoint and message type.
+    ///
+    /// # Arguments
+    /// * `eid` - The endpoint ID
+    /// * `msg_type` - The OApp message type
+    /// * `extra_options` - Additional options passed by the caller
+    ///
+    /// # Returns
+    /// * `ByteArray` - The combination of caller specified options AND enforced options
+    fn combine_options(
+        self: @TContractState, eid: u32, msg_type: u16, extra_options: ByteArray,
+    ) -> ByteArray;
+
+    /// Gets the enforced options for a specific endpoint and message type
+    ///
+    /// # Arguments
+    /// * `eid` - The endpoint ID
+    /// * `msg_type` - The OApp message type
+    ///
+    /// # Returns
+    /// * `ByteArray` - The enforced options
+    fn get_enforced_options(self: @TContractState, eid: u32, msg_type: u16) -> ByteArray;
+}

package/layerzero/src/oapps/common/oapp_options_type_3/oapp_options_type_3.cairo

@@ -0,0 +1,120 @@
+#[starknet::component]
+pub mod OAppOptionsType3Component {
+    use alexandria_bytes::byte_array_ext::ByteArrayTraitExt;
+    use core::panics::panic_with_byte_array;
+    use openzeppelin::access::ownable::OwnableComponent;
+    use openzeppelin::access::ownable::OwnableComponent::{
+        InternalImpl as OwnableInternalImpl, InternalTrait as OwnableInternalTrait,
+    };
+    use starknet::storage::{Map, StorageMapReadAccess, StorageMapWriteAccess};
+    use starkware_utils::errors::assert_with_byte_array;
+    use crate::oapps::common::oapp_options_type_3::errors::err_invalid_options;
+    use crate::oapps::common::oapp_options_type_3::events::EnforcedOptionSet;
+    use crate::oapps::common::oapp_options_type_3::interface::IOAppOptionsType3;
+    use crate::oapps::common::oapp_options_type_3::structs::EnforcedOptionParam;
+
+    // Constants
+    pub const OPTION_TYPE_3: u16 = 3;
+
+    #[storage]
+    pub struct Storage {
+        /// Mapping from (eid, msg_type) => enforced options
+        OAppOptionsType3_enforced_options: Map<(u32, u16), ByteArray>,
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    pub enum Event {
+        EnforcedOptionSet: EnforcedOptionSet,
+    }
+
+    #[generate_trait]
+    pub impl InternalImpl<
+        TContractState, +HasComponent<TContractState>,
+    > of InternalTrait<TContractState> {
+        /// Internal function to set enforced options
+        fn _set_enforced_options(
+            ref self: ComponentState<TContractState>, enforced_options: Array<EnforcedOptionParam>,
+        ) {
+            for option in enforced_options.clone().into_iter() {
+                // Enforced options are only available for optionType 3
+                self._assert_options_type_3(@option.options);
+
+                // Store the enforced option
+                self
+                    .OAppOptionsType3_enforced_options
+                    .write((option.eid, option.msg_type), option.options.clone());
+            }
+
+            self.emit(EnforcedOptionSet { options: enforced_options });
+        }
+
+        /// Internal function to assert that options are of type 3
+        fn _assert_options_type_3(self: @ComponentState<TContractState>, options: @ByteArray) {
+            // Use the ByteArrayTraitExt to read u16 from the beginning
+            let (_, option_type) = options.read_u16(0);
+
+            assert_with_byte_array(option_type == OPTION_TYPE_3, err_invalid_options(options));
+        }
+    }
+
+    #[embeddable_as(OAppOptionsType3Impl)]
+    impl OAppOptionsType3<
+        TContractState,
+        +HasComponent<TContractState>,
+        impl Ownable: OwnableComponent::HasComponent<TContractState>,
+    > of IOAppOptionsType3<ComponentState<TContractState>> {
+        fn set_enforced_options(
+            ref self: ComponentState<TContractState>, enforced_options: Array<EnforcedOptionParam>,
+        ) {
+            // Only owner can set enforced options
+            let ownable = get_dep_component!(@self, Ownable);
+            ownable.assert_only_owner();
+
+            self._set_enforced_options(enforced_options);
+        }
+
+        fn combine_options(
+            self: @ComponentState<TContractState>,
+            eid: u32,
+            msg_type: u16,
+            extra_options: ByteArray,
+        ) -> ByteArray {
+            let enforced = self.OAppOptionsType3_enforced_options.read((eid, msg_type));
+
+            // No enforced options, pass whatever the caller supplied
+            if enforced.len() == 0 {
+                return extra_options;
+            }
+
+            // No caller options, return enforced
+            if extra_options.len() == 0 {
+                return enforced;
+            }
+
+            // If caller provided extra_options, must be type 3 as it's the ONLY type that can be
+            // combined
+            if extra_options.len() >= 2 {
+                self._assert_options_type_3(@extra_options);
+
+                // Remove the first 2 bytes containing the type from the extra_options and combine
+                // with enforced
+                let mut combined = enforced;
+                if extra_options.len() > 2 {
+                    let (_, extra_data) = extra_options.read_bytes(2, extra_options.len() - 2);
+                    combined.append(@extra_data);
+                }
+                return combined;
+            }
+
+            // No valid set of options was found
+            panic_with_byte_array(@err_invalid_options(@extra_options));
+        }
+
+        fn get_enforced_options(
+            self: @ComponentState<TContractState>, eid: u32, msg_type: u16,
+        ) -> ByteArray {
+            self.OAppOptionsType3_enforced_options.read((eid, msg_type))
+        }
+    }
+}

package/layerzero/src/oapps/common/oapp_options_type_3/structs.cairo

@@ -0,0 +1,6 @@
+#[derive(Drop, Serde, Clone)]
+pub struct EnforcedOptionParam {
+    pub eid: u32,
+    pub msg_type: u16,
+    pub options: ByteArray,
+}

package/layerzero/src/oapps/counter/constants.cairo

@@ -0,0 +1,3 @@
+// Increment types
+pub const INCREMENT_TYPE_A_B: u8 = 0x01; // A->B increment (no response)
+pub const INCREMENT_TYPE_A_B_A: u8 = 0x02; // A->B->A increment (with response)

package/layerzero/src/oapps/counter/counter.cairo

@@ -0,0 +1,170 @@
+#[starknet::contract]
+pub mod OmniCounter {
+    use alexandria_bytes::byte_array_ext::ByteArrayTraitExt;
+    use lz_utils::bytes::Bytes32;
+    use openzeppelin::access::ownable::OwnableComponent;
+    use starknet::storage::{
+        Map, StoragePathEntry, StoragePointerReadAccess, StoragePointerWriteAccess,
+    };
+    use starknet::{ContractAddress, get_caller_address};
+    use crate::common::structs::messaging::{MessageReceipt, MessagingFee};
+    use crate::common::structs::packet::Origin;
+    use crate::oapps::counter::constants::{INCREMENT_TYPE_A_B, INCREMENT_TYPE_A_B_A};
+    use crate::oapps::counter::interface::IOmniCounter;
+    use crate::oapps::counter::structs::{IncrementReceived, IncrementSent};
+    use crate::oapps::oapp::oapp_core::OAppCoreComponent;
+
+    component!(path: OAppCoreComponent, storage: oapp_core, event: OAppCoreEvent);
+    component!(path: OwnableComponent, storage: ownable, event: OwnableEvent);
+
+    // OAppCore Mixin - now with built-in ownership control
+    #[abi(embed_v0)]
+    impl OAppCoreImpl = OAppCoreComponent::OAppCoreImpl<ContractState>;
+    impl OAppCoreInternalImpl = OAppCoreComponent::InternalImpl<ContractState>;
+    impl OAppCoreSenderImpl = OAppCoreComponent::OAppSenderImpl<ContractState>;
+
+    #[abi(embed_v0)]
+    impl OAppCoreReceiverImpl = OAppCoreComponent::OAppReceiverImpl<ContractState>;
+
+    #[abi(embed_v0)]
+    impl ILayerZeroReceiverImpl =
+        OAppCoreComponent::LayerZeroReceiverImpl<ContractState>;
+
+    // Ownable Mixin
+    #[abi(embed_v0)]
+    impl OwnableImpl = OwnableComponent::OwnableImpl<ContractState>;
+    impl OwnableInternalImpl = OwnableComponent::InternalImpl<ContractState>;
+
+    #[storage]
+    struct Storage {
+        // Map from remoteEid to counter value
+        counters: Map<u32, u256>,
+        #[substorage(v0)]
+        oapp_core: OAppCoreComponent::Storage,
+        #[substorage(v0)]
+        ownable: OwnableComponent::Storage,
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    pub enum Event {
+        #[flat]
+        OAppCoreEvent: OAppCoreComponent::Event,
+        #[flat]
+        OwnableEvent: OwnableComponent::Event,
+        IncrementSent: IncrementSent,
+        IncrementReceived: IncrementReceived,
+    }
+
+    #[constructor]
+    fn constructor(
+        ref self: ContractState,
+        endpoint: ContractAddress,
+        owner: ContractAddress,
+        native_token: ContractAddress,
+    ) {
+        self.oapp_core.initializer(endpoint, native_token);
+        self.ownable.initializer(owner);
+    }
+
+
+    #[abi(embed_v0)]
+    impl OmniCounterImpl of IOmniCounter<ContractState> {
+        fn get_counter(self: @ContractState, remote_eid: u32) -> u256 {
+            self.counters.entry(remote_eid).read()
+        }
+
+        fn quote(
+            self: @ContractState,
+            dst_eid: u32,
+            increment_type: u8,
+            options: ByteArray,
+            pay_in_lz_token: bool,
+        ) -> MessagingFee {
+            self
+                .oapp_core
+                ._quote(
+                    dst_eid,
+                    self._encode_increment_message(increment_type),
+                    options,
+                    pay_in_lz_token,
+                )
+        }
+
+        fn increment(
+            ref self: ContractState,
+            dst_eid: u32,
+            increment_type: u8,
+            options: ByteArray,
+            fee: MessagingFee,
+            refund_address: ContractAddress,
+        ) -> MessageReceipt {
+            let caller = get_caller_address();
+            let message = self._encode_increment_message(increment_type);
+
+            self.emit(IncrementSent { sender: caller, dst_eid, increment_type });
+
+            // Call the underlying OAppCore send function
+            self.oapp_core._lz_send(dst_eid, message, options, fee, refund_address)
+        }
+    }
+
+    #[generate_trait]
+    impl InternalImpl of InternalTrait {
+        /// Encode increment message for cross-chain communication
+        fn _encode_increment_message(self: @ContractState, increment_type: u8) -> ByteArray {
+            let mut message: ByteArray = "";
+
+            // Message Format:
+            // 1 byte: Increment type (AB=0x01, ABA=0x02)
+            message.append_byte(increment_type);
+
+            message
+        }
+
+        /// Send a response increment back to the original sender (for ABA type)
+        fn _send_response(ref self: ContractState, dst_eid: u32) {
+            // Use default options and fee for response (in real implementation, these should be
+            // configurable)
+            let options: ByteArray = "";
+            let fee = MessagingFee { native_fee: 0, lz_token_fee: 0 };
+            let refund_address = get_caller_address();
+
+            self.increment(dst_eid, INCREMENT_TYPE_A_B, options, fee, refund_address);
+        }
+    }
+
+    // Implement IOAppHooks to provide the required _lz_receive implementation
+    impl IOAppHooks<ContractState> of OAppCoreComponent::IOAppHooks<ContractState> {
+        fn _lz_receive(
+            ref self: OAppCoreComponent::ComponentState<ContractState>,
+            origin: Origin,
+            guid: Bytes32,
+            message: ByteArray,
+            executor: ContractAddress,
+            value: u256,
+            extra_data: ByteArray,
+        ) {
+            let mut contract_state = unsafe_new_contract_state();
+            // Parse the message
+            let (_, increment_type) = message.read_u8(0);
+
+            // Get the source EID
+            let src_eid = origin.src_eid;
+
+            // Increment the counter for this remote EID
+            let counter_entry = contract_state.counters.entry(src_eid);
+            let old_value = counter_entry.read();
+            let new_value = old_value + 1;
+            counter_entry.write(new_value);
+
+            contract_state
+                .emit(IncrementReceived { src_eid, old_value, new_value, increment_type, value });
+
+            // If this is an ABA type increment, send a response back
+            if increment_type == INCREMENT_TYPE_A_B_A {
+                contract_state._send_response(src_eid);
+            }
+        }
+    }
+}

package/layerzero/src/oapps/counter/interface.cairo

@@ -0,0 +1,27 @@
+use starknet::ContractAddress;
+use crate::common::structs::messaging::{MessageReceipt, MessagingFee};
+
+#[starknet::interface]
+pub trait IOmniCounter<TContractState> {
+    /// Get the counter value for a specific remote EID.
+    fn get_counter(self: @TContractState, remote_eid: u32) -> u256;
+
+    /// Quote an increment.
+    fn quote(
+        self: @TContractState,
+        dst_eid: u32,
+        increment_type: u8,
+        options: ByteArray,
+        pay_in_lz_token: bool,
+    ) -> MessagingFee;
+
+    /// Send an increment message to another chain.
+    fn increment(
+        ref self: TContractState,
+        dst_eid: u32,
+        increment_type: u8,
+        options: ByteArray,
+        fee: MessagingFee,
+        refund_address: ContractAddress,
+    ) -> MessageReceipt;
+}

package/layerzero/src/oapps/counter/structs.cairo

@@ -0,0 +1,20 @@
+use starknet::ContractAddress;
+
+#[derive(Drop, starknet::Event)]
+pub struct IncrementSent {
+    #[key]
+    pub sender: ContractAddress,
+    #[key]
+    pub dst_eid: u32,
+    pub increment_type: u8,
+}
+
+#[derive(Drop, starknet::Event)]
+pub struct IncrementReceived {
+    #[key]
+    pub src_eid: u32,
+    pub old_value: u256,
+    pub new_value: u256,
+    pub increment_type: u8,
+    pub value: u256,
+}

package/layerzero/src/oapps/message_inspector/interface.cairo

@@ -0,0 +1,21 @@
+//! Message inspector interface
+
+/// IMessageInspector defines the complete interface for message inspection.
+#[starknet::interface]
+pub trait IMessageInspector<TContractState> {
+    /// Inspect the message and options
+    ///
+    /// This function is called to inspect the message and options before they are sent.
+    /// If the message or options fail inspection, the transaction will revert.
+    ///
+    /// # Arguments
+    /// * `message` - The message to inspect
+    /// * `options` - The options to inspect
+    ///
+    /// # Returns
+    /// * `bool` - True if the message and options pass inspection, false otherwise
+    ///
+    /// # Panics
+    /// * If the message or options fail inspection, the transaction will revert
+    fn inspect_msg(self: @TContractState, message: ByteArray, options: ByteArray) -> bool;
+}

package/layerzero/src/oapps/oapp/errors.cairo

@@ -0,0 +1,72 @@
+use lz_utils::bytes::Bytes32;
+use lz_utils::error::{Error, format_error};
+use starknet::ContractAddress;
+
+#[derive(Drop)]
+pub enum OAppCoreError {
+    OnlyEndpoint,
+    OnlyPeer,
+    NoPeer,
+    NotEnoughNative,
+    NotEnoughNativeAllowance,
+    NotEnoughLzToken,
+    NotEnoughLzTokenAllowance,
+    LzTokenUnavailable,
+}
+
+impl ErrorNameImpl of Error<OAppCoreError> {
+    fn prefix() -> ByteArray {
+        "LZ_OAPP_CORE"
+    }
+
+    fn name(self: OAppCoreError) -> ByteArray {
+        match self {
+            OAppCoreError::OnlyEndpoint => "ONLY_ENDPOINT",
+            OAppCoreError::OnlyPeer => "ONLY_PEER",
+            OAppCoreError::NoPeer => "NO_PEER",
+            OAppCoreError::NotEnoughNative => "NOT_ENOUGH_NATIVE",
+            OAppCoreError::NotEnoughNativeAllowance => "NOT_ENOUGH_NATIVE_ALLOWANCE",
+            OAppCoreError::NotEnoughLzToken => "NOT_ENOUGH_LZ_TOKEN",
+            OAppCoreError::NotEnoughLzTokenAllowance => "NOT_ENOUGH_LZ_TOKEN_ALLOWANCE",
+            OAppCoreError::LzTokenUnavailable => "LZ_TOKEN_UNAVAILABLE",
+        }
+    }
+}
+
+pub fn err_only_endpoint(endpoint: ContractAddress) -> ByteArray {
+    format_error(OAppCoreError::OnlyEndpoint, format!("{:?}", endpoint))
+}
+
+pub fn err_only_peer(eid: u32, peer: Bytes32) -> ByteArray {
+    format_error(OAppCoreError::OnlyPeer, format!("eid: {:?}, peer: {:?}", eid, peer))
+}
+
+pub fn err_no_peer(eid: u32) -> ByteArray {
+    format_error(OAppCoreError::NoPeer, format!("eid: {:?}", eid))
+}
+
+pub fn err_not_enough_native(fee: u256, balance: u256) -> ByteArray {
+    format_error(OAppCoreError::NotEnoughNative, format!("fee: {:?}, balance: {:?}", fee, balance))
+}
+
+pub fn err_not_enough_lz_token(fee: u256, balance: u256) -> ByteArray {
+    format_error(OAppCoreError::NotEnoughLzToken, format!("fee: {:?}, balance: {:?}", fee, balance))
+}
+
+pub fn err_lz_token_unavailable() -> ByteArray {
+    format_error(OAppCoreError::LzTokenUnavailable, "")
+}
+
+pub fn err_not_enough_lz_token_allowance(fee: u256, allowance: u256) -> ByteArray {
+    format_error(
+        OAppCoreError::NotEnoughLzTokenAllowance,
+        format!("fee: {:?}, allowance: {:?}", fee, allowance),
+    )
+}
+
+pub fn err_not_enough_native_allowance(fee: u256, allowance: u256) -> ByteArray {
+    format_error(
+        OAppCoreError::NotEnoughNativeAllowance,
+        format!("fee: {:?}, allowance: {:?}", fee, allowance),
+    )
+}

package/layerzero/src/oapps/oapp/events.cairo

@@ -0,0 +1,9 @@
+use lz_utils::bytes::Bytes32;
+
+#[derive(Drop, starknet::Event)]
+pub struct PeerSet {
+    #[key]
+    pub eid: u32,
+    #[key]
+    pub peer: Bytes32,
+}

package/layerzero/src/oapps/oapp/interface.cairo

@@ -0,0 +1,67 @@
+use lz_utils::bytes::Bytes32;
+use starknet::ContractAddress;
+use crate::Origin;
+
+#[starknet::interface]
+pub trait IOApp<TContractState> {
+    /// Gets the LayerZero endpoint contract address
+    ///
+    /// # Returns
+    ///
+    /// The contract address of the LayerZero endpoint
+    fn get_endpoint(self: @TContractState) -> ContractAddress;
+
+    /// Sets a peer for a specific endpoint ID
+    /// This establishes a trusted connection to another OApp on a different chain
+    ///
+    /// # Arguments
+    ///
+    /// * `eid`: The endpoint ID of the destination chain
+    /// * `peer`: The peer address as a 32-byte value
+    fn set_peer(ref self: TContractState, eid: u32, peer: Bytes32);
+
+    /// Gets the peer address for a specific endpoint ID
+    ///
+    /// # Arguments
+    ///
+    /// * `eid`: The endpoint ID of the destination chain
+    ///
+    /// # Returns
+    ///
+    /// The peer address as a 32-byte value
+    fn get_peer(self: @TContractState, eid: u32) -> Bytes32;
+
+    /// Returns the OApp version information
+    ///
+    /// # Returns
+    ///
+    /// A tuple containing (sender_version, receiver_version) as u64 values
+    fn oapp_version(self: @TContractState) -> (u64, u64);
+
+    /// Sets the send library for a specific endpoint ID
+    ///
+    /// # Arguments
+    ///
+    /// * `dst_eid`: The destination endpoint ID
+    /// * `delegate`: The contract address of the delegate
+    fn set_delegate(ref self: TContractState, delegate: ContractAddress);
+}
+
+#[starknet::interface]
+pub trait IOAppReceiver<TContractState> {
+    /// Verifies if a sender is authorized for compose message operations
+    /// This is used in message composition scenarios to validate senders
+    ///
+    /// # Arguments
+    ///
+    /// * `origin`: The origin information of the message
+    /// * `message`: The message content to validate
+    /// * `sender`: The contract address claiming to be the sender
+    ///
+    /// # Returns
+    ///
+    /// True if the sender is authorized for compose messages, false otherwise
+    fn is_compose_msg_sender(
+        self: @TContractState, origin: Origin, message: ByteArray, sender: ContractAddress,
+    ) -> bool;
+}

package/layerzero/src/oapps/oapp/oapp.cairo

@@ -0,0 +1,70 @@
+/// OApp - Simple LayerZero OApp using integrated OAppCore functionality
+#[starknet::contract]
+pub mod OApp {
+    use layerzero::oapps::oapp::oapp_core::OAppCoreComponent;
+    use lz_utils::bytes::Bytes32;
+    // Core OApp implementation - all types are provided by the component traits
+    use openzeppelin::access::ownable::OwnableComponent;
+    use starknet::ContractAddress;
+    use crate::Origin;
+
+    component!(path: OAppCoreComponent, storage: oapp_core, event: OAppCoreEvent);
+    component!(path: OwnableComponent, storage: ownable, event: OwnableEvent);
+
+    // OAppCore Mixin - Core functionality
+    #[abi(embed_v0)]
+    impl OAppCoreImpl = OAppCoreComponent::OAppCoreImpl<ContractState>;
+    #[abi(embed_v0)]
+    impl ILayerZeroReceiverImpl =
+        OAppCoreComponent::LayerZeroReceiverImpl<ContractState>;
+    #[abi(embed_v0)]
+    impl IOAppReceiverImpl = OAppCoreComponent::OAppReceiverImpl<ContractState>;
+    impl OAppCoreInternalImpl = OAppCoreComponent::InternalImpl<ContractState>;
+
+    // Ownable Mixin
+    #[abi(embed_v0)]
+    impl OwnableImpl = OwnableComponent::OwnableImpl<ContractState>;
+    impl OwnableInternalImpl = OwnableComponent::InternalImpl<ContractState>;
+
+    #[storage]
+    struct Storage {
+        #[substorage(v0)]
+        oapp_core: OAppCoreComponent::Storage,
+        #[substorage(v0)]
+        ownable: OwnableComponent::Storage,
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    pub enum Event {
+        #[flat]
+        OAppCoreEvent: OAppCoreComponent::Event,
+        #[flat]
+        OwnableEvent: OwnableComponent::Event,
+    }
+
+    #[constructor]
+    fn constructor(
+        ref self: ContractState,
+        endpoint: ContractAddress,
+        owner: ContractAddress,
+        native_token: ContractAddress,
+    ) {
+        self.oapp_core.initializer(endpoint, native_token);
+        self.ownable.initializer(owner);
+    }
+
+    // Implement IOFTHooks to provide the specific token operations
+    impl IOAppHooks<ContractState> of OAppCoreComponent::IOAppHooks<ContractState> {
+        fn _lz_receive(
+            ref self: OAppCoreComponent::ComponentState<ContractState>,
+            origin: Origin,
+            guid: Bytes32,
+            message: ByteArray,
+            executor: ContractAddress,
+            value: u256,
+            extra_data: ByteArray,
+        ) { // Contract should implement receive logic here
+        }
+    }
+}