@layerzerolabs/protocol-starknet-v2 0.0.34

package/layerzero/tests/mocks/messaging_composer.cairo

@@ -0,0 +1,171 @@
+//! Mock messaging composer contract
+
+#[starknet::contract]
+pub mod MockMessagingComposer {
+    use layerzero::common::constants::ZERO_ADDRESS;
+    use layerzero::endpoint::messaging_composer::events::{ComposeDelivered, LzComposeAlert};
+    use layerzero::endpoint::messaging_composer::interface::IMessagingComposer;
+    use layerzero::endpoint::messaging_composer::messaging_composer::MessagingComposerComponent;
+    use layerzero::endpoint::messaging_composer::messaging_composer::MessagingComposerComponent::Event as MessagingComposerEvent;
+    use lz_utils::bytes::Bytes32;
+    use starknet::ContractAddress;
+    use starknet::storage::{StoragePointerReadAccess, StoragePointerWriteAccess};
+
+    component!(
+        path: MessagingComposerComponent,
+        storage: messaging_composer,
+        event: MessagingComposerEvent,
+    );
+
+    impl MessagingComposerInternalImpl = MessagingComposerComponent::InternalImpl<ContractState>;
+
+    #[storage]
+    struct Storage {
+        /// Whether the messaging composer is real or mock
+        is_real: bool,
+        /// Whether the messaging composer should fail to compose
+        should_compose_fail: bool,
+        #[substorage(v0)]
+        messaging_composer: MessagingComposerComponent::Storage,
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    pub enum Event {
+        #[flat]
+        MessagingComposerEvent: MessagingComposerComponent::Event,
+    }
+
+    #[constructor]
+    fn constructor(ref self: ContractState, token_address: ContractAddress) {
+        self.is_real.write(true);
+        self.should_compose_fail.write(false);
+        self.messaging_composer.initializer(token_address);
+    }
+
+    #[abi(embed_v0)]
+    pub impl MockMessagingComposerImpl of IMessagingComposer<ContractState> {
+        /// Delegate to messaging composer
+        fn send_compose(
+            ref self: ContractState,
+            to: ContractAddress,
+            guid: Bytes32,
+            index: u16,
+            message: ByteArray,
+        ) {
+            self.messaging_composer.send_compose(to, guid, index, message);
+        }
+
+        /// If the messaging composer is in mock mode:
+        ///
+        /// - if `should_compose_fail` is true, emit LzComposeAlert event
+        ///
+        /// - otherwise, emit ComposeDelivered event
+        fn lz_compose(
+            ref self: ContractState,
+            from: ContractAddress,
+            to: ContractAddress,
+            guid: Bytes32,
+            index: u16,
+            message: ByteArray,
+            extra_data: ByteArray,
+            value: u256,
+        ) {
+            if self.is_real.read() {
+                self
+                    .messaging_composer
+                    .lz_compose(from, to, guid, index, message.clone(), extra_data.clone(), value);
+            }
+
+            // Mock messaging composer
+            if self.should_compose_fail.read() {
+                let reason = array!['MockComposer: lz_compose failed'];
+                self.lz_compose_alert(from, to, guid, index, 0, value, message, extra_data, reason);
+            } else {
+                self
+                    .emit(
+                        MessagingComposerEvent::ComposeDelivered(
+                            ComposeDelivered { from, to, guid, index },
+                        ),
+                    );
+            }
+        }
+
+        /// If mock messaging composer - emit LzComposeAlert event
+        fn lz_compose_alert(
+            ref self: ContractState,
+            from: ContractAddress,
+            to: ContractAddress,
+            guid: Bytes32,
+            index: u16,
+            gas: u256,
+            value: u256,
+            message: ByteArray,
+            extra_data: ByteArray,
+            reason: Array<felt252>,
+        ) {
+            if self.is_real.read() {
+                self
+                    .messaging_composer
+                    .lz_compose_alert(
+                        from,
+                        to,
+                        guid,
+                        index,
+                        gas,
+                        value,
+                        message.clone(),
+                        extra_data.clone(),
+                        reason.clone(),
+                    );
+            }
+
+            // Mock messaging composer
+            self
+                .emit(
+                    MessagingComposerEvent::LzComposeAlert(
+                        LzComposeAlert {
+                            from,
+                            to,
+                            executor: ZERO_ADDRESS,
+                            guid,
+                            index,
+                            gas,
+                            value,
+                            message,
+                            extra_data,
+                            reason,
+                        },
+                    ),
+                );
+        }
+
+        fn get_compose_queue(
+            self: @ContractState,
+            sender: ContractAddress,
+            to: ContractAddress,
+            guid: Bytes32,
+            index: u16,
+        ) -> Bytes32 {
+            self.messaging_composer.get_compose_queue(sender, to, guid, index)
+        }
+    }
+
+    /// Mock messaging composer helpers
+    #[starknet::interface]
+    pub trait MockMessagingComposerHelpers<TContractState> {
+        fn set_is_real(ref self: TContractState, is_real: bool);
+        fn set_should_compose_fail(ref self: TContractState, should_fail: bool);
+    }
+
+    #[abi(embed_v0)]
+    pub impl MockMessagingComposerHelpersImpl of MockMessagingComposerHelpers<ContractState> {
+        fn set_is_real(ref self: ContractState, is_real: bool) {
+            self.is_real.write(is_real);
+        }
+
+        fn set_should_compose_fail(ref self: ContractState, should_fail: bool) {
+            self.should_compose_fail.write(should_fail);
+        }
+    }
+}

package/layerzero/tests/mocks/oapp_core/interface.cairo

@@ -0,0 +1,53 @@
+//! Mock OAppCore interface for testing
+
+/// Trait to expose internal functions
+#[starknet::interface]
+pub trait IMockOAppCore<TContractState> {
+    // Internal functions from InternalTrait
+    fn test_assert_only_endpoint(self: @TContractState);
+    fn test_assert_only_owner(self: @TContractState);
+    fn test_get_peer_or_revert(self: @TContractState, eid: u32) -> lz_utils::bytes::Bytes32;
+
+    // Internal functions from OAppSender
+    fn test_quote(
+        self: @TContractState,
+        dst_eid: u32,
+        message: ByteArray,
+        options: ByteArray,
+        pay_in_lz_token: bool,
+    ) -> layerzero::common::structs::messaging::MessagingFee;
+
+    fn test_lz_send(
+        ref self: TContractState,
+        dst_eid: u32,
+        message: ByteArray,
+        options: ByteArray,
+        fee: layerzero::common::structs::messaging::MessagingFee,
+        refund_address: starknet::ContractAddress,
+    ) -> layerzero::common::structs::messaging::MessageReceipt;
+
+    fn test_pay_native(
+        self: @TContractState,
+        caller: starknet::ContractAddress,
+        endpoint: starknet::ContractAddress,
+        contract_address: starknet::ContractAddress,
+        fee: u256,
+    );
+
+    fn test_pay_lz_token(
+        self: @TContractState,
+        caller: starknet::ContractAddress,
+        endpoint: starknet::ContractAddress,
+        contract_address: starknet::ContractAddress,
+        fee: u256,
+    );
+
+    fn test_pay_in_token(
+        self: @TContractState,
+        caller: starknet::ContractAddress,
+        endpoint: starknet::ContractAddress,
+        contract_address: starknet::ContractAddress,
+        fee: u256,
+        token_address: starknet::ContractAddress,
+    );
+}

package/layerzero/tests/mocks/oapp_core/oapp_core.cairo

@@ -0,0 +1,142 @@
+//! Mock OAppCore component for testing
+
+/// OApp - Simple LayerZero OApp using integrated OAppCore functionality
+#[starknet::contract]
+pub mod MockOAppCore {
+    use layerzero::common::structs::packet::Origin;
+    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::mocks::oapp_core::interface::IMockOAppCore;
+
+    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>;
+    impl OAppSenderImpl = OAppCoreComponent::OAppSenderImpl<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,
+        stark_token: ContractAddress,
+    ) {
+        self.oapp_core.initializer(endpoint, stark_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
+        }
+    }
+
+    #[abi(embed_v0)]
+    impl MockOAppCoreTestImpl of IMockOAppCore<ContractState> {
+        // Expose internal functions for testing
+        fn test_assert_only_endpoint(self: @ContractState) {
+            self.oapp_core._assert_only_endpoint();
+        }
+
+        fn test_assert_only_owner(self: @ContractState) {
+            self.oapp_core._assert_only_owner();
+        }
+
+        fn test_get_peer_or_revert(self: @ContractState, eid: u32) -> Bytes32 {
+            self.oapp_core._get_peer_or_revert(eid)
+        }
+
+        fn test_quote(
+            self: @ContractState,
+            dst_eid: u32,
+            message: ByteArray,
+            options: ByteArray,
+            pay_in_lz_token: bool,
+        ) -> layerzero::common::structs::messaging::MessagingFee {
+            self.oapp_core._quote(dst_eid, message, options, pay_in_lz_token)
+        }
+
+        fn test_lz_send(
+            ref self: ContractState,
+            dst_eid: u32,
+            message: ByteArray,
+            options: ByteArray,
+            fee: layerzero::common::structs::messaging::MessagingFee,
+            refund_address: ContractAddress,
+        ) -> layerzero::common::structs::messaging::MessageReceipt {
+            self.oapp_core._lz_send(dst_eid, message, options, fee, refund_address)
+        }
+
+        fn test_pay_native(
+            self: @ContractState,
+            caller: ContractAddress,
+            endpoint: ContractAddress,
+            contract_address: ContractAddress,
+            fee: u256,
+        ) {
+            self.oapp_core._pay_native(caller, endpoint, contract_address, fee);
+        }
+
+        fn test_pay_lz_token(
+            self: @ContractState,
+            caller: ContractAddress,
+            endpoint: ContractAddress,
+            contract_address: ContractAddress,
+            fee: u256,
+        ) {
+            self.oapp_core._pay_lz_token(caller, endpoint, contract_address, fee);
+        }
+
+        fn test_pay_in_token(
+            self: @ContractState,
+            caller: ContractAddress,
+            endpoint: ContractAddress,
+            contract_address: ContractAddress,
+            fee: u256,
+            token_address: ContractAddress,
+        ) {
+            self.oapp_core._pay_in_token(caller, endpoint, contract_address, fee, token_address);
+        }
+    }
+}

package/layerzero/tests/mocks/oapp_options_type3.cairo

@@ -0,0 +1,42 @@
+//! Mock OAppOptionsType3 component for testing
+
+#[starknet::contract]
+pub mod MockOAppOptionsType3 {
+    use layerzero::oapps::common::oapp_options_type_3::oapp_options_type_3::OAppOptionsType3Component;
+    use openzeppelin::access::ownable::OwnableComponent;
+    use starknet::ContractAddress;
+
+    component!(path: OwnableComponent, storage: ownable, event: OwnableEvent);
+    component!(path: OAppOptionsType3Component, storage: oapp_options, event: OAppOptionsEvent);
+
+    #[abi(embed_v0)]
+    impl OwnableImpl = OwnableComponent::OwnableImpl<ContractState>;
+    impl OwnableInternalImpl = OwnableComponent::InternalImpl<ContractState>;
+
+    #[abi(embed_v0)]
+    impl OAppOptionsType3Impl =
+        OAppOptionsType3Component::OAppOptionsType3Impl<ContractState>;
+    impl OAppOptionsType3InternalImpl = OAppOptionsType3Component::InternalImpl<ContractState>;
+
+    #[storage]
+    struct Storage {
+        #[substorage(v0)]
+        ownable: OwnableComponent::Storage,
+        #[substorage(v0)]
+        oapp_options: OAppOptionsType3Component::Storage,
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    enum Event {
+        #[flat]
+        OwnableEvent: OwnableComponent::Event,
+        #[flat]
+        OAppOptionsEvent: OAppOptionsType3Component::Event,
+    }
+
+    #[constructor]
+    fn constructor(ref self: ContractState, owner: ContractAddress) {
+        self.ownable.initializer(owner);
+    }
+}

package/layerzero/tests/mocks/oft_core/interface.cairo

@@ -0,0 +1,28 @@
+//! Mock OFT Core interface for testing
+
+use layerzero::oapps::oft::structs::{OFTDebit, OFTMsgAndOptions, SendParam};
+use starknet::ContractAddress;
+
+/// Trait to expose internal OFT Core functions for testing
+#[starknet::interface]
+pub trait IMockOFTCore<TContractState> {
+    // Internal functions from OFTCore InternalTrait
+    fn test_to_ld(self: @TContractState, amount_sd: u64) -> u256;
+    fn test_to_sd(self: @TContractState, amount_ld: u256) -> u64;
+    fn test_remove_dust(self: @TContractState, amount_ld: u256) -> u256;
+    fn test_debit_view(
+        self: @TContractState, amount_ld: u256, min_amount_ld: u256, dst_eid: u32,
+    ) -> OFTDebit;
+    fn test_build_msg_and_options(
+        self: @TContractState, send_param: SendParam, amount_ld: u256,
+    ) -> OFTMsgAndOptions;
+
+    fn test_set_msg_inspector(ref self: TContractState, msg_inspector: ContractAddress);
+
+    // Storage access functions
+    fn test_shared_decimals(self: @TContractState) -> u8;
+    fn test_decimal_conversion_rate(self: @TContractState) -> u256;
+
+    // Initialize function for testing
+    fn test_initializer(ref self: TContractState, local_decimals: u8);
+}

package/layerzero/tests/mocks/oft_core/oft_core.cairo

@@ -0,0 +1,242 @@
+//! Mock OFT Core component for testing
+
+/// MockOFTCore - Contract to test OFT Core internal functions
+#[starknet::contract]
+pub mod MockOFTCore {
+    use layerzero::common::structs::packet::Origin;
+    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 layerzero::oapps::oft::structs::{OFTDebit, OFTMsgAndOptions, SendParam};
+    use lz_utils::bytes::Bytes32;
+    use openzeppelin::access::ownable::OwnableComponent;
+    use openzeppelin::token::erc20::{ERC20Component, ERC20HooksEmptyImpl};
+    use starknet::storage::{StoragePointerReadAccess, StoragePointerWriteAccess};
+    use starknet::{ContractAddress, get_contract_address};
+    use crate::mocks::oft_core::interface::IMockOFTCore;
+
+
+    // 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 = 18;
+    }
+
+    // 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,
+        // Add our own storage to access internal values
+        test_decimal_conversion_rate: u256,
+    }
+
+    #[event]
+    #[derive(Drop, starknet::Event)]
+    pub 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,
+        lz_endpoint: ContractAddress,
+        owner: ContractAddress,
+        stark_token: ContractAddress,
+    ) {
+        // Initialize ERC20 with test values
+        self.erc20.initializer("MockOFT", "MOFT");
+
+        // Initialize Ownable
+        self.ownable.initializer(owner);
+
+        // Initialize OApp Core
+        self.oapp_core.initializer(lz_endpoint, stark_token);
+
+        // Initialize OFT Core with test values (will be overridden in tests)
+        let local_decimals = self.erc20.decimals();
+        self.oft_core.initializer(local_decimals);
+
+        // Store the conversion rate for testing access
+        self.test_decimal_conversion_rate.write(1000000000000_u256); // 10^(18-6)
+    }
+
+    // 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();
+
+            // Mint tokens to recipient
+            contract_state.erc20.mint(to, 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 {
+            6
+        }
+    }
+
+    // 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);
+        }
+    }
+
+    #[abi(embed_v0)]
+    impl MockOFTCoreTestImpl of IMockOFTCore<ContractState> {
+        // Expose internal functions for testing
+        fn test_to_ld(self: @ContractState, amount_sd: u64) -> u256 {
+            self.oft_core._to_ld(amount_sd)
+        }
+
+        fn test_to_sd(self: @ContractState, amount_ld: u256) -> u64 {
+            self.oft_core._to_sd(amount_ld)
+        }
+
+        fn test_remove_dust(self: @ContractState, amount_ld: u256) -> u256 {
+            self.oft_core._remove_dust(amount_ld)
+        }
+
+        fn test_debit_view(
+            self: @ContractState, amount_ld: u256, min_amount_ld: u256, dst_eid: u32,
+        ) -> OFTDebit {
+            self.oft_core._debit_view(amount_ld, min_amount_ld, dst_eid)
+        }
+
+        fn test_build_msg_and_options(
+            self: @ContractState, send_param: SendParam, amount_ld: u256,
+        ) -> OFTMsgAndOptions {
+            self.oft_core._build_msg_and_options(@send_param, amount_ld)
+        }
+
+        fn test_set_msg_inspector(ref self: ContractState, msg_inspector: ContractAddress) {
+            self.oft_core.set_msg_inspector(msg_inspector);
+        }
+
+        fn test_shared_decimals(self: @ContractState) -> u8 {
+            self.oft_core.shared_decimals()
+        }
+
+        fn test_decimal_conversion_rate(self: @ContractState) -> u256 {
+            self.test_decimal_conversion_rate.read()
+        }
+
+        fn test_initializer(ref self: ContractState, local_decimals: u8) {
+            self.oft_core.initializer(local_decimals);
+            let shared_decimals = self.oft_core.shared_decimals();
+
+            // Calculate and store the conversion rate for testing
+            let decimals_diff = local_decimals - shared_decimals;
+            let rate = if decimals_diff == 0 {
+                1_u256
+            } else if decimals_diff == 12 {
+                1000000000000_u256 // 10^12
+            } else {
+                // For simplicity, only handle common cases
+                1_u256
+            };
+            self.test_decimal_conversion_rate.write(rate);
+        }
+    }
+}