@layerzerolabs/protocol-starknet-v2 0.0.34

package/layerzero/src/oapps/oft/oft.cairo

@@ -0,0 +1,188 @@
+/// OFT (Omnichain Fungible Token) Contract
+/// Standard ERC20 token with cross-chain transfer capabilities
+#[starknet::contract]
+pub mod OFT {
+    use core::num::traits::Zero;
+    use layerzero::oapps::common::oapp_options_type_3::oapp_options_type_3::OAppOptionsType3Component;
+    use layerzero::oapps::oapp::oapp_core::OAppCoreComponent;
+    use layerzero::oapps::oft::oft_core::OFTCoreComponent;
+    use lz_utils::bytes::Bytes32;
+    use openzeppelin::access::ownable::OwnableComponent;
+    use openzeppelin::token::erc20::{ERC20Component, ERC20HooksEmptyImpl};
+    use starknet::{ContractAddress, get_contract_address};
+    use crate::Origin;
+    use crate::common::constants::DEAD_ADDRESS;
+    use crate::oapps::oft::structs::OFTDebit;
+
+    const SHARED_DECIMALS: u8 = 6;
+
+    // Component declarations
+    component!(path: ERC20Component, storage: erc20, event: ERC20Event);
+    component!(path: OwnableComponent, storage: ownable, event: OwnableEvent);
+    component!(path: OAppCoreComponent, storage: oapp_core, event: OAppCoreEvent);
+    component!(path: OFTCoreComponent, storage: oft_core, event: OFTCoreEvent);
+    component!(
+        path: OAppOptionsType3Component, storage: oapp_options_type_3, event: OAppOptionsType3Event,
+    );
+
+    // ERC20 Mixin
+    #[abi(embed_v0)]
+    impl ERC20MixinImpl = ERC20Component::ERC20MixinImpl<ContractState>;
+    impl ERC20InternalImpl = ERC20Component::InternalImpl<ContractState>;
+
+    // ERC20 immutable configuration
+    impl ERC20ImmutableConfig of ERC20Component::ImmutableConfig {
+        const DECIMALS: u8 = ERC20Component::DEFAULT_DECIMALS;
+    }
+
+    // Ownable Mixin
+    #[abi(embed_v0)]
+    impl OwnableMixinImpl = OwnableComponent::OwnableMixinImpl<ContractState>;
+    impl OwnableInternalImpl = OwnableComponent::InternalImpl<ContractState>;
+
+    // OApp Core
+    #[abi(embed_v0)]
+    impl OAppCoreImpl = OAppCoreComponent::OAppCoreImpl<ContractState>;
+    impl OAppCoreInternalImpl = OAppCoreComponent::InternalImpl<ContractState>;
+
+    // OApp Receiver
+    #[abi(embed_v0)]
+    impl IOAppReceiverImpl = OAppCoreComponent::OAppReceiverImpl<ContractState>;
+
+    // LayerZero Receiver from OApp Core
+    #[abi(embed_v0)]
+    impl ILayerZeroReceiverImpl =
+        OAppCoreComponent::LayerZeroReceiverImpl<ContractState>;
+
+    // OFT Core - embed the implementation
+    #[abi(embed_v0)]
+    impl OFTCoreImpl = OFTCoreComponent::OFTCoreImpl<ContractState>;
+    impl OFTCoreInternalImpl = OFTCoreComponent::InternalImpl<ContractState>;
+
+    // OApp Options Type 3
+    #[abi(embed_v0)]
+    impl OAppOptionsType3Impl =
+        OAppOptionsType3Component::OAppOptionsType3Impl<ContractState>;
+    impl OAppOptionsType3InternalImpl = OAppOptionsType3Component::InternalImpl<ContractState>;
+
+    #[storage]
+    struct Storage {
+        #[substorage(v0)]
+        erc20: ERC20Component::Storage,
+        #[substorage(v0)]
+        ownable: OwnableComponent::Storage,
+        #[substorage(v0)]
+        oapp_core: OAppCoreComponent::Storage,
+        #[substorage(v0)]
+        oft_core: OFTCoreComponent::Storage,
+        #[substorage(v0)]
+        oapp_options_type_3: OAppOptionsType3Component::Storage,
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    enum Event {
+        #[flat]
+        ERC20Event: ERC20Component::Event,
+        #[flat]
+        OwnableEvent: OwnableComponent::Event,
+        #[flat]
+        OAppCoreEvent: OAppCoreComponent::Event,
+        #[flat]
+        OFTCoreEvent: OFTCoreComponent::Event,
+        #[flat]
+        OAppOptionsType3Event: OAppOptionsType3Component::Event,
+    }
+
+    #[constructor]
+    fn constructor(
+        ref self: ContractState,
+        name: ByteArray,
+        symbol: ByteArray,
+        lz_endpoint: ContractAddress,
+        owner: ContractAddress,
+        native_token: ContractAddress,
+    ) {
+        // Initialize ERC20
+        self.erc20.initializer(name, symbol);
+
+        // Initialize Ownable
+        self.ownable.initializer(owner);
+
+        // Initialize OApp Core
+        self.oapp_core.initializer(lz_endpoint, native_token);
+
+        // Initialize OFT Core with local decimals
+        let local_decimals = self.erc20.decimals();
+        self.oft_core.initializer(local_decimals);
+    }
+
+    // Implement IOFTHooks to provide the specific token operations
+    impl IOFTHooks<ContractState> of OFTCoreComponent::IOFTHooks<ContractState> {
+        fn _debit(
+            ref self: OFTCoreComponent::ComponentState<ContractState>,
+            from: ContractAddress,
+            amount: u256,
+            min_amount: u256,
+            dst_eid: u32,
+        ) -> OFTDebit {
+            let mut contract_state = unsafe_new_contract_state();
+
+            let oft_debit = contract_state.oft_core._debit_view(amount, min_amount, dst_eid);
+
+            // Burn tokens from sender
+            contract_state.erc20.burn(from, oft_debit.amount_sent_ld);
+
+            oft_debit
+        }
+
+        fn _credit(
+            ref self: OFTCoreComponent::ComponentState<ContractState>,
+            to: ContractAddress,
+            amount: u256,
+            src_eid: u32,
+        ) -> u256 {
+            let mut contract_state = unsafe_new_contract_state();
+            // Handle the zero address case
+            let recipient = if to.is_zero() {
+                DEAD_ADDRESS
+            } else {
+                to
+            };
+
+            // Mint tokens to recipient
+            contract_state.erc20.mint(recipient, amount);
+
+            // Return the actual amount received (same as input in default implementation)
+            amount
+        }
+
+        fn _token(self: @OFTCoreComponent::ComponentState<ContractState>) -> ContractAddress {
+            get_contract_address()
+        }
+
+        fn _approval_required(self: @OFTCoreComponent::ComponentState<ContractState>) -> bool {
+            false
+        }
+
+        fn _shared_decimals(self: @OFTCoreComponent::ComponentState<ContractState>) -> u8 {
+            SHARED_DECIMALS
+        }
+    }
+
+    // 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();
+            contract_state.oft_core._lz_receive(origin, guid, message, executor, value, extra_data);
+        }
+    }
+}

package/layerzero/src/oapps/oft/oft_adapter.cairo

@@ -0,0 +1,175 @@
+/// OFT Adapter Contract
+/// Wraps an existing ERC20 token for cross-chain transfers using lock/unlock mechanism
+#[starknet::contract]
+pub mod OFTAdapter {
+    use layerzero::oapps::common::oapp_options_type_3::oapp_options_type_3::OAppOptionsType3Component;
+    use layerzero::oapps::oapp::oapp_core::OAppCoreComponent;
+    use layerzero::oapps::oft::oft_core::OFTCoreComponent;
+    use lz_utils::bytes::Bytes32;
+    use openzeppelin::access::ownable::OwnableComponent;
+    use openzeppelin::token::erc20::interface::{
+        IERC20Dispatcher, IERC20DispatcherTrait, IERC20MetadataDispatcher,
+        IERC20MetadataDispatcherTrait,
+    };
+    use starknet::storage::{StoragePointerReadAccess, StoragePointerWriteAccess};
+    use starknet::{ContractAddress, get_contract_address};
+    use crate::Origin;
+    use crate::oapps::oft::structs::OFTDebit;
+
+    // Default shared decimals for OFT
+    const SHARED_DECIMALS: u8 = 6;
+
+    // Component declarations
+    component!(path: OwnableComponent, storage: ownable, event: OwnableEvent);
+    component!(path: OAppCoreComponent, storage: oapp_core, event: OAppCoreEvent);
+    component!(path: OFTCoreComponent, storage: oft_core, event: OFTCoreEvent);
+    component!(
+        path: OAppOptionsType3Component, storage: oapp_options_type_3, event: OAppOptionsType3Event,
+    );
+
+    // Ownable Mixin
+    #[abi(embed_v0)]
+    impl OwnableMixinImpl = OwnableComponent::OwnableMixinImpl<ContractState>;
+    impl OwnableInternalImpl = OwnableComponent::InternalImpl<ContractState>;
+
+    // OApp Core
+    #[abi(embed_v0)]
+    impl OAppCoreImpl = OAppCoreComponent::OAppCoreImpl<ContractState>;
+    impl OAppCoreInternalImpl = OAppCoreComponent::InternalImpl<ContractState>;
+
+
+    // OApp Receiver
+    #[abi(embed_v0)]
+    impl IOAppReceiverImpl = OAppCoreComponent::OAppReceiverImpl<ContractState>;
+    #[abi(embed_v0)]
+    impl ILayerZeroReceiverImpl =
+        OAppCoreComponent::LayerZeroReceiverImpl<ContractState>;
+
+    // OFT Core - embed the implementation
+    #[abi(embed_v0)]
+    impl OFTCoreImpl = OFTCoreComponent::OFTCoreImpl<ContractState>;
+    impl OFTCoreInternalImpl = OFTCoreComponent::InternalImpl<ContractState>;
+
+    // OApp Options Type 3
+    #[abi(embed_v0)]
+    impl OAppOptionsType3Impl =
+        OAppOptionsType3Component::OAppOptionsType3Impl<ContractState>;
+    impl OAppOptionsType3InternalImpl = OAppOptionsType3Component::InternalImpl<ContractState>;
+
+    #[storage]
+    struct Storage {
+        #[substorage(v0)]
+        ownable: OwnableComponent::Storage,
+        #[substorage(v0)]
+        oapp_core: OAppCoreComponent::Storage,
+        #[substorage(v0)]
+        oft_core: OFTCoreComponent::Storage,
+        #[substorage(v0)]
+        oapp_options_type_3: OAppOptionsType3Component::Storage,
+        erc20_token: ContractAddress,
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    enum Event {
+        #[flat]
+        OwnableEvent: OwnableComponent::Event,
+        #[flat]
+        OAppCoreEvent: OAppCoreComponent::Event,
+        #[flat]
+        OFTCoreEvent: OFTCoreComponent::Event,
+        #[flat]
+        OAppOptionsType3Event: OAppOptionsType3Component::Event,
+    }
+
+    #[constructor]
+    fn constructor(
+        ref self: ContractState,
+        erc20_token: ContractAddress,
+        lz_endpoint: ContractAddress,
+        owner: ContractAddress,
+        native_token: ContractAddress,
+    ) {
+        // Initialize Ownable
+        self.ownable.initializer(owner);
+
+        // Initialize OApp Core
+        self.oapp_core.initializer(lz_endpoint, native_token);
+
+        // Initialize token address
+        self.erc20_token.write(erc20_token);
+
+        // OFT Core needs to read local decimals from already deployed ERC20 token
+        let token_dispatcher = IERC20MetadataDispatcher { contract_address: erc20_token };
+
+        // Initialize OFT Core with local decimals
+        self.oft_core.initializer(token_dispatcher.decimals());
+    }
+
+    // Implement IOFTHooks to provide the specific token operations
+    impl IOFTHooks<ContractState> of OFTCoreComponent::IOFTHooks<ContractState> {
+        fn _debit(
+            ref self: OFTCoreComponent::ComponentState<ContractState>,
+            from: ContractAddress,
+            amount: u256,
+            min_amount: u256,
+            dst_eid: u32,
+        ) -> OFTDebit {
+            let mut contract_state = unsafe_new_contract_state();
+
+            let oft_debit = contract_state.oft_core._debit_view(amount, min_amount, dst_eid);
+
+            // Lock tokens by transferring them from the caller to this contract
+            let token = IERC20Dispatcher { contract_address: contract_state.erc20_token.read() };
+            token.transfer_from(from, get_contract_address(), oft_debit.amount_sent_ld);
+
+            oft_debit
+        }
+
+        fn _credit(
+            ref self: OFTCoreComponent::ComponentState<ContractState>,
+            to: ContractAddress,
+            amount: u256,
+            src_eid: u32,
+        ) -> u256 {
+            let mut contract_state = unsafe_new_contract_state();
+            // Get the erc20 token dispatcher
+            let token = IERC20Dispatcher { contract_address: contract_state.erc20_token.read() };
+
+            // Unlock tokens by transferring them from this contract to the recipient
+            token.transfer(to, amount);
+
+            // Return the actual amount received (same as input in default implementation)
+            amount
+        }
+
+        fn _token(self: @OFTCoreComponent::ComponentState<ContractState>) -> ContractAddress {
+            let mut contract_state = unsafe_new_contract_state();
+            contract_state.erc20_token.read()
+        }
+
+        fn _approval_required(self: @OFTCoreComponent::ComponentState<ContractState>) -> bool {
+            true
+        }
+
+        fn _shared_decimals(self: @OFTCoreComponent::ComponentState<ContractState>) -> u8 {
+            SHARED_DECIMALS
+        }
+    }
+
+    // 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();
+            contract_state.oft_core._lz_receive(origin, guid, message, executor, value, extra_data);
+        }
+    }
+}

package/layerzero/src/oapps/oft/oft_compose_msg_codec.cairo

@@ -0,0 +1,128 @@
+/// OFTComposeMsgCodec - Cairo implementation of the Solidity OFTComposeMsgCodec library
+/// Handles encoding and decoding of OFT composed messages
+pub mod OFTComposeMsgCodec {
+    use alexandria_bytes::byte_array_ext::ByteArrayTraitExt;
+    use lz_utils::bytes::Bytes32;
+    use starknet::ContractAddress;
+
+    // Offset constants for encoding and decoding OFT compose messages
+    pub const NONCE_OFFSET: usize = 8;
+    pub const SRC_EID_OFFSET: usize = 12;
+    pub const AMOUNT_LD_OFFSET: usize = 44;
+    pub const COMPOSE_FROM_OFFSET: usize = 76;
+
+    /// Encodes an OFT composed message.
+    ///
+    /// # Arguments
+    /// * `nonce` - The nonce value (u64)
+    /// * `src_eid` - The source endpoint ID (u32)
+    /// * `amount_ld` - The amount in local decimals (u256)
+    /// * `compose_msg` - The composed message (composeFrom + composeMsg)
+    ///
+    /// # Returns
+    /// * `ByteArray` - The encoded composed message
+    pub fn encode(nonce: u64, src_eid: u32, amount_ld: u256, compose_msg: @ByteArray) -> ByteArray {
+        let mut message: ByteArray = Default::default();
+
+        // Encode nonce (8 bytes)
+        message.append_u64(nonce);
+
+        // Encode src_eid (4 bytes)
+        message.append_u32(src_eid);
+
+        // Encode amount_ld (32 bytes)
+        message.append_u256(amount_ld);
+
+        // Append compose message
+        message.append(compose_msg);
+
+        message
+    }
+
+    /// Retrieves the nonce from the composed message.
+    ///
+    /// # Arguments
+    /// * `message` - The composed message
+    ///
+    /// # Returns
+    /// * `u64` - The nonce value
+    pub fn nonce(message: @ByteArray) -> u64 {
+        let (_, nonce_value) = message.read_u64(0);
+        nonce_value
+    }
+
+    /// Retrieves the source endpoint ID from the composed message.
+    ///
+    /// # Arguments
+    /// * `message` - The composed message
+    ///
+    /// # Returns
+    /// * `u32` - The source endpoint ID
+    pub fn src_eid(message: @ByteArray) -> u32 {
+        let (_, src_eid_value) = message.read_u32(NONCE_OFFSET);
+        src_eid_value
+    }
+
+    /// Retrieves the amount in local decimals from the composed message.
+    ///
+    /// # Arguments
+    /// * `message` - The composed message
+    ///
+    /// # Returns
+    /// * `u256` - The amount in local decimals
+    pub fn amount_ld(message: @ByteArray) -> u256 {
+        let (_, amount_value) = message.read_u256(SRC_EID_OFFSET);
+        amount_value
+    }
+
+    /// Retrieves the composeFrom value from the composed message.
+    ///
+    /// # Arguments
+    /// * `message` - The composed message
+    ///
+    /// # Returns
+    /// * `Bytes32` - The composeFrom value
+    pub fn compose_from(message: @ByteArray) -> Bytes32 {
+        let (_, compose_from_value) = message.read_u256(AMOUNT_LD_OFFSET);
+        Bytes32 { value: compose_from_value }
+    }
+
+    /// Retrieves the composed message.
+    ///
+    /// # Arguments
+    /// * `message` - The full composed message
+    ///
+    /// # Returns
+    /// * `ByteArray` - The composed message portion
+    pub fn compose_msg(message: @ByteArray) -> ByteArray {
+        if message.len() > COMPOSE_FROM_OFFSET {
+            let compose_length = message.len() - COMPOSE_FROM_OFFSET;
+            let (_, compose_value) = message.read_bytes(COMPOSE_FROM_OFFSET, compose_length);
+            compose_value
+        } else {
+            Default::default()
+        }
+    }
+
+    /// Converts a ContractAddress to Bytes32.
+    ///
+    /// # Arguments
+    /// * `addr` - The address to convert
+    ///
+    /// # Returns
+    /// * `Bytes32` - The bytes32 representation
+    pub fn address_to_bytes32(addr: ContractAddress) -> Bytes32 {
+        addr.into()
+    }
+
+    /// Converts Bytes32 to a ContractAddress.
+    ///
+    /// # Arguments
+    /// * `b` - The bytes32 value to convert
+    ///
+    /// # Returns
+    /// * `Option<ContractAddress>` - The address if valid
+    pub fn bytes32_to_address(b: Bytes32) -> Option<ContractAddress> {
+        b.try_into()
+    }
+}