@layerzerolabs/oft-adapter-starknet 0.2.9

package/Scarb.lock

@@ -0,0 +1,190 @@
+# Code generated by scarb DO NOT EDIT.
+version = 1
+
+[[package]]
+name = "enumerable_set"
+version = "0.1.0"
+
+[[package]]
+name = "layerzero"
+version = "0.1.0"
+dependencies = [
+ "enumerable_set",
+ "lz_utils",
+ "multisig",
+ "openzeppelin",
+]
+
+[[package]]
+name = "lz_utils"
+version = "0.1.0"
+
+[[package]]
+name = "multisig"
+version = "0.1.0"
+dependencies = [
+ "enumerable_set",
+ "lz_utils",
+]
+
+[[package]]
+name = "oft_adapter"
+version = "0.1.0"
+dependencies = [
+ "layerzero",
+ "lz_utils",
+ "openzeppelin",
+ "snforge_std",
+ "starkware_utils_testing",
+]
+
+[[package]]
+name = "openzeppelin"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:5e4fdecc957cfca7854d95912dc72d9f725517c063b116512900900add29fd77"
+dependencies = [
+ "openzeppelin_access",
+ "openzeppelin_account",
+ "openzeppelin_finance",
+ "openzeppelin_governance",
+ "openzeppelin_introspection",
+ "openzeppelin_merkle_tree",
+ "openzeppelin_presets",
+ "openzeppelin_security",
+ "openzeppelin_token",
+ "openzeppelin_upgrades",
+ "openzeppelin_utils",
+]
+
+[[package]]
+name = "openzeppelin_access"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:511681dd26d814ee2bc996d44ff8cb4aaa5ae9d14272130def7eb901cf004850"
+dependencies = [
+ "openzeppelin_introspection",
+]
+
+[[package]]
+name = "openzeppelin_account"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:fb3381c50d68b028d3801feb43df378e2bd62137b6884844f8f60aefe796188b"
+dependencies = [
+ "openzeppelin_introspection",
+ "openzeppelin_utils",
+]
+
+[[package]]
+name = "openzeppelin_finance"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:e9456ef69502a87c4c99bf50145351b50950f8b11244847d92935c466c4ba787"
+dependencies = [
+ "openzeppelin_access",
+ "openzeppelin_token",
+]
+
+[[package]]
+name = "openzeppelin_governance"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:056e6d6f3d48193b53f06283884f8a9675f986fc85425f6a40e8c1aeb3b3ecfa"
+dependencies = [
+ "openzeppelin_access",
+ "openzeppelin_account",
+ "openzeppelin_introspection",
+ "openzeppelin_token",
+ "openzeppelin_utils",
+]
+
+[[package]]
+name = "openzeppelin_introspection"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:87773ed6cd2318f169283ecbbb161890d1996260a80302d81ec45b70ee5e54c1"
+
+[[package]]
+name = "openzeppelin_merkle_tree"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:47f80c9ce59557774243214f8e75c5e866f30f3d8daa755855f6ffd01c89ca89"
+
+[[package]]
+name = "openzeppelin_presets"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:36c761ee923f1dc0887c0eab8c224b49ac242dbfe9163fbb0b08562042ab3d98"
+dependencies = [
+ "openzeppelin_access",
+ "openzeppelin_account",
+ "openzeppelin_finance",
+ "openzeppelin_introspection",
+ "openzeppelin_token",
+ "openzeppelin_upgrades",
+ "openzeppelin_utils",
+]
+
+[[package]]
+name = "openzeppelin_security"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:902932ec296c2f400e0ac7c579edeaafd6067b6ce6d9854c1191de28e396ffe3"
+
+[[package]]
+name = "openzeppelin_token"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:6fe61f63b5a6706018265fb7373b6e5bd3ff829bdc760b2b90296b1e708d180c"
+dependencies = [
+ "openzeppelin_access",
+ "openzeppelin_account",
+ "openzeppelin_introspection",
+ "openzeppelin_utils",
+]
+
+[[package]]
+name = "openzeppelin_upgrades"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:560d57a9c3f3ec5a476e82fec8963c93c8df63a4ff9ff134f64ab8383bde3c61"
+
+[[package]]
+name = "openzeppelin_utils"
+version = "2.0.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:bf799c794139837f397975ffdf6a7ed5032d198bbf70e87a8f44f144a9dfc505"
+
+[[package]]
+name = "snforge_scarb_plugin"
+version = "0.49.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:903150f0e9542e4277d417029eea4c03af0db398b581f9f7ae3ebbdac9afc657"
+
+[[package]]
+name = "snforge_std"
+version = "0.49.0"
+source = "registry+https://scarbs.xyz/"
+checksum = "sha256:73d73653cc4356ec51b92a6bec9d8385b20318170c2f2ade7891e5185a0e7e64"
+dependencies = [
+ "snforge_scarb_plugin",
+]
+
+[[package]]
+name = "starkware_utils"
+version = "1.0.0"
+source = "git+https://github.com/starkware-libs/starkware-starknet-utils?rev=e1955423808045de868987b8fb0b43f5cbdf5699#e1955423808045de868987b8fb0b43f5cbdf5699"
+dependencies = [
+ "openzeppelin",
+]
+
+[[package]]
+name = "starkware_utils_testing"
+version = "1.0.0"
+source = "git+https://github.com/starkware-libs/starkware-starknet-utils?rev=e1955423808045de868987b8fb0b43f5cbdf5699#e1955423808045de868987b8fb0b43f5cbdf5699"
+dependencies = [
+ "openzeppelin",
+ "snforge_std",
+ "starkware_utils",
+]

package/Scarb.toml

@@ -0,0 +1,4 @@
+[workspace]
+members = ["contracts/*"]
+
+

package/contracts/oft_adapter/Scarb.toml

@@ -0,0 +1,30 @@
+[package]
+name = "oft_adapter"
+version = "0.1.0"
+edition = "2024_07"
+
+# See more keys and their definitions at https://docs.swmansion.com/scarb/docs/reference/manifest.html
+
+[dependencies]
+starknet = "2.14.0"
+openzeppelin = "2.0.0"
+lz_utils = { path = "../../node_modules/@layerzerolabs/protocol-starknet-v2/libs/lz_utils" }
+layerzero = { path = "../../node_modules/@layerzerolabs/protocol-starknet-v2/layerzero" }
+
+[dev-dependencies]
+snforge_std = "0.49.0"
+assert_macros = "2.12.0"
+starkware_utils_testing = { git = "https://github.com/starkware-libs/starkware-starknet-utils", rev = "e1955423808045de868987b8fb0b43f5cbdf5699" }
+
+[[target.starknet-contract]]
+sierra = true
+casm = true
+
+
+[scripts]
+test = "snforge test"
+
+[tool.scarb]
+allow-prebuilt-plugins = ["snforge_scarb_plugin", "snforge_std"]
+
+

package/contracts/oft_adapter/src/lib.cairo

@@ -0,0 +1 @@
+pub mod oft_adapter;

package/contracts/oft_adapter/src/oft_adapter.cairo

@@ -0,0 +1,150 @@
+/// 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::errors::err_oft_transfer_failed;
+    use layerzero::oapps::oft::oft_core::default_oapp_hooks::OFTCoreOAppHooksDefaultImpl;
+    use layerzero::oapps::oft::oft_core::oft_core::OFTCoreComponent;
+    use layerzero::oapps::oft::structs::OFTDebit;
+    use lz_utils::error::assert_with_byte_array;
+    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};
+
+    // 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>;
+
+    const SHARED_DECIMALS: u8 = 6;
+
+    // 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, owner, 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(), SHARED_DECIMALS);
+    }
+
+    // Implement OFTHooks to provide the specific token operations
+    impl OFTHooks of OFTCoreComponent::OFTHooks<ContractState> {
+        fn _debit(
+            ref self: OFTCoreComponent::ComponentState<ContractState>,
+            from: ContractAddress,
+            amount: u256,
+            min_amount: u256,
+            dst_eid: u32,
+        ) -> OFTDebit {
+            let oft_debit = self._debit_view(amount, min_amount, dst_eid);
+
+            // Lock tokens by transferring them from the caller to this contract
+            let success = IERC20Dispatcher { contract_address: self._token() }
+                .transfer_from(from, get_contract_address(), oft_debit.amount_sent_ld);
+            assert_with_byte_array(success, err_oft_transfer_failed());
+
+            oft_debit
+        }
+
+        fn _credit(
+            ref self: OFTCoreComponent::ComponentState<ContractState>,
+            to: ContractAddress,
+            amount: u256,
+            src_eid: u32,
+        ) -> u256 {
+            // Unlock tokens by transferring them from this contract to the recipient
+            let success = IERC20Dispatcher { contract_address: self._token() }.transfer(to, amount);
+            assert_with_byte_array(success, err_oft_transfer_failed());
+
+            // Return the actual amount received (same as input in default implementation)
+            amount
+        }
+
+        fn _token(self: @OFTCoreComponent::ComponentState<ContractState>) -> ContractAddress {
+            self.get_contract().erc20_token.read()
+        }
+
+        fn _approval_required(self: @OFTCoreComponent::ComponentState<ContractState>) -> bool {
+            true
+        }
+    }
+}

package/contracts/oft_adapter/tests/constants.cairo

@@ -0,0 +1,3 @@
+pub fn assert_eq<T, +PartialEq<T>, +Drop<T>>(a: T, b: T) {
+    assert(a == b, 'Should be equal');
+}

package/contracts/oft_adapter/tests/lib.cairo

@@ -0,0 +1,11 @@
+pub mod constants;
+pub mod test_oft_adapter;
+pub mod mocks {
+    pub mod erc20 {
+        pub mod erc20;
+        pub mod interface;
+    }
+    pub mod message_inspector {
+        pub mod message_inspector;
+    }
+}

package/contracts/oft_adapter/tests/mocks/erc20/erc20.cairo

@@ -0,0 +1,49 @@
+//! Mock ERC20 component for testing
+
+#[starknet::contract]
+pub mod MockERC20 {
+    use openzeppelin::token::erc20::{ERC20Component, ERC20HooksEmptyImpl};
+    use starknet::ContractAddress;
+    use crate::mocks::erc20::interface::IMockERC20;
+
+    component!(path: ERC20Component, storage: erc20, event: ERC20Event);
+
+    impl ERC20ImmutableConfig of ERC20Component::ImmutableConfig {
+        const DECIMALS: u8 = 18;
+    }
+
+    #[abi(embed_v0)]
+    impl ERC20MixinImpl = ERC20Component::ERC20MixinImpl<ContractState>;
+    impl ERC20InternalImpl = ERC20Component::InternalImpl<ContractState>;
+
+    #[storage]
+    struct Storage {
+        #[substorage(v0)]
+        erc20: ERC20Component::Storage,
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    enum Event {
+        #[flat]
+        ERC20Event: ERC20Component::Event,
+    }
+
+    #[constructor]
+    fn constructor(ref self: ContractState, initial_supply: u256, recipient: ContractAddress) {
+        let name = "MyToken";
+        let symbol = "MTK";
+
+        self.erc20.initializer(name, symbol);
+        self.erc20.mint(recipient, initial_supply);
+    }
+
+    #[abi(embed_v0)]
+    impl MockERC20Impl of IMockERC20<ContractState> {
+        fn mint(ref self: ContractState, recipient: ContractAddress, amount: u256) {
+            // This function is NOT protected which means
+            // ANYONE can mint tokens
+            self.erc20.mint(recipient, amount);
+        }
+    }
+}

package/contracts/oft_adapter/tests/mocks/erc20/interface.cairo

@@ -0,0 +1,8 @@
+//! Mock ERC20 interface for testing
+
+use starknet::ContractAddress;
+
+#[starknet::interface]
+pub trait IMockERC20<TContractState> {
+    fn mint(ref self: TContractState, recipient: ContractAddress, amount: u256);
+}

package/contracts/oft_adapter/tests/mocks/message_inspector/message_inspector.cairo

@@ -0,0 +1,17 @@
+//! Mock Message Inspector component for testing
+
+#[starknet::contract]
+pub mod MockMessageInspector {
+    use core::panics::panic_with_byte_array;
+    use layerzero::oapps::message_inspector::interface::IMessageInspector;
+
+    #[storage]
+    struct Storage {}
+
+    #[abi(embed_v0)]
+    impl MockMessageInspectorImpl of IMessageInspector<ContractState> {
+        fn inspect_msg(self: @ContractState, message: ByteArray, options: ByteArray) -> bool {
+            panic_with_byte_array(@"Invalid message or options")
+        }
+    }
+}