Refactor Aptos module and utility functions for improved message handling

- Renamed `DecodedMessage` struct to `ReceiveData` for clarity.
- Simplified message parsing logic in `parse_message` function.
- Updated `lz_receive_impl` to utilize the new `ReceiveData` struct.
- Removed unused utility functions and constants from `utils.move`.
- Added unit tests for `parse_message` to ensure correct functionality.

Author: AlexanderLiteplo

examples/oapp-aptos-move/sources/oapp.move

@@ -32,7 +32,7 @@ module oapp::oapp {
         value: u64
     }
 
-    struct DecodedMessage has key {
+    struct ReceiveData has key {
         address1: address,
         address2: address,
         number: u256,
@@ -42,7 +42,7 @@ module oapp::oapp {
 
     fun init_module(account: &signer) {
         move_to(account, Counter { value: 0 });
-        move_to(account, DecodedMessage { 
+        move_to(account, ReceiveData { 
             address1: @0x0, 
             address2: @0x0, 
             number: 0, 
@@ -51,36 +51,20 @@ module oapp::oapp {
         });
     }
 
-    public(friend) fun lz_receive_impl(
-        _src_eid: u32,
-        _sender: Bytes32,
-        _nonce: u64,
-        _guid: Bytes32,
-        _message: vector<u8>,
-        _extra_data: vector<u8>,
-        receive_value: Option<FungibleAsset>,
-    ) acquires Counter, DecodedMessage {
-        option::destroy(receive_value, |value| primary_fungible_store::deposit(OAPP_ADDRESS(), value));
-
-        let counter = borrow_global_mut<Counter>(OAPP_ADDRESS());
-        counter.value = counter.value + 1;
-
+    public fun parse_message(message: vector<u8>): (address, address, u256) {
         let string_length = (
-            (*vector::borrow(&_message, 60) as u64) << 24 |
-            (*vector::borrow(&_message, 61) as u64) << 16 |
-            (*vector::borrow(&_message, 62) as u64) << 8 |
-            (*vector::borrow(&_message, 63) as u64)
+            (*vector::borrow(&message, 60) as u64) << 24 |
+            (*vector::borrow(&message, 61) as u64) << 16 |
+            (*vector::borrow(&message, 62) as u64) << 8 |
+            (*vector::borrow(&message, 63) as u64)
         );
 
         let string_start = 64;
         let string_end = string_start + string_length;
-        let string_bytes = vector::slice(&_message, string_start, string_end);
-        let decoded_string = bytes_to_string(string_bytes);
-        
-        let string_content_bytes = *string::bytes(&decoded_string);
-        let hex_part_bytes = vector::slice(&string_content_bytes, 2, vector::length(&string_content_bytes));
-        let hex_part_string = bytes_to_string(hex_part_bytes);
-        let hex_content = hex_string_to_bytes(hex_part_string);
+        let string_bytes = vector::slice(&message, string_start, string_end);
+
+        let hex_bytes = vector::slice(&string_bytes, 2, vector::length(&string_bytes));
+        let hex_content = hex_string_to_bytes(string::utf8(hex_bytes));
 
         let addr1_bytes = vector::slice(&hex_content, 0, 32);
         let decoded_addr1 = from_bcs::to_address(addr1_bytes);
@@ -104,12 +88,31 @@ module oapp::oapp {
             j = j + 1;
         };
 
-        let decoded_message = borrow_global_mut<DecodedMessage>(OAPP_ADDRESS());
-        decoded_message.address1 = decoded_addr1;
-        decoded_message.address2 = decoded_addr2;
-        decoded_message.number = number_u256;
-        decoded_message.counter = counter.value;
-        decoded_message.raw_message = _message;
+        (decoded_addr1, decoded_addr2, number_u256)
+    }
+
+    public(friend) fun lz_receive_impl(
+        _src_eid: u32,
+        _sender: Bytes32,
+        _nonce: u64,
+        _guid: Bytes32,
+        _message: vector<u8>,
+        _extra_data: vector<u8>,
+        receive_value: Option<FungibleAsset>,
+    ) acquires Counter, ReceiveData {
+        option::destroy(receive_value, |value| primary_fungible_store::deposit(OAPP_ADDRESS(), value));
+
+        let counter = borrow_global_mut<Counter>(OAPP_ADDRESS());
+        counter.value = counter.value + 1;
+
+        let (decoded_addr1, decoded_addr2, number_u256) = parse_message(_message);
+
+        let receive_data = borrow_global_mut<ReceiveData>(OAPP_ADDRESS());
+        receive_data.address1 = decoded_addr1;
+        receive_data.address2 = decoded_addr2;
+        receive_data.number = number_u256;
+        receive_data.counter = counter.value;
+        receive_data.raw_message = _message;
     }
 
     // todo: replicate the logic in here where sending a message must happen
@@ -188,18 +191,18 @@ module oapp::oapp {
     // ================================================== View Functions ===========================================
 
     #[view]
-    public fun get_decoded_address1(): address acquires DecodedMessage {
-        borrow_global<DecodedMessage>(OAPP_ADDRESS()).address1
+    public fun get_decoded_address1(): address acquires ReceiveData {
+        borrow_global<ReceiveData>(OAPP_ADDRESS()).address1
     }
 
     #[view]
-    public fun get_decoded_address2(): address acquires DecodedMessage {
-        borrow_global<DecodedMessage>(OAPP_ADDRESS()).address2
+    public fun get_decoded_address2(): address acquires ReceiveData {
+        borrow_global<ReceiveData>(OAPP_ADDRESS()).address2
     }
 
     #[view]
-    public fun get_decoded_number(): u256 acquires DecodedMessage {
-        borrow_global<DecodedMessage>(OAPP_ADDRESS()).number
+    public fun get_decoded_number(): u256 acquires ReceiveData {
+        borrow_global<ReceiveData>(OAPP_ADDRESS()).number
     }
 
     #[view]
@@ -208,8 +211,8 @@ module oapp::oapp {
     }
 
     #[view]
-    public fun get_raw_message(): vector<u8> acquires DecodedMessage {
-        borrow_global<DecodedMessage>(OAPP_ADDRESS()).raw_message
+    public fun get_raw_message(): vector<u8> acquires ReceiveData {
+        borrow_global<ReceiveData>(OAPP_ADDRESS()).raw_message
     }
 
     // ================================================== Error Codes =================================================
@@ -218,4 +221,6 @@ module oapp::oapp {
     const EINSUFFICIENT_BALANCE: u64 = 2;
     const EINVALID_HEX_CHAR: u64 = 3;
     const EINVALID_LENGTH: u64 = 4;
+
+
 }

examples/oapp-aptos-move/sources/utils.move

@@ -15,26 +15,17 @@ module oapp::utils {
         *string::bytes(&str)
     }
 
-    /// Safely converts a vector of bytes to a UTF-8 string
-    /// Returns an Option: Some(string) if valid UTF-8, None if invalid
-    public fun try_bytes_to_string(bytes: vector<u8>): std::option::Option<String> {
-        if (string::try_utf8(bytes) != std::option::none()) {
-            std::option::some(string::utf8(bytes))
-        } else {
-            std::option::none()
-        }
-    }
-
     /// Converts a hex string (without 0x prefix) to a vector of bytes
     /// Example: "48656c6c6f" -> b"Hello"
     /// Automatically pads odd-length strings with a leading zero
     public fun hex_string_to_bytes(hex_str: String): vector<u8> {
         let hex_bytes = string::bytes(&hex_str);
         let len = vector::length(hex_bytes);
 
+        // If the hex string is odd length, pad with leading zero
         let padded_hex = if (len % 2 == 1) {
             let padded = vector::empty<u8>();
-            vector::push_back(&mut padded, 48);
+            vector::push_back(&mut padded, ASCII_ZERO);
             vector::append(&mut padded, *hex_bytes);
             padded
         } else {
@@ -54,27 +45,6 @@ module oapp::utils {
         result
     }
 
-    /// Converts a hex string to an Aptos address
-    /// Supports both with and without 0x prefix
-    /// The hex string should represent exactly 32 bytes (64 hex characters)
-    public fun hex_string_to_address(hex_str: String): address {
-        let clean_hex = strip_hex_prefix(hex_str);
-        let hex_bytes = hex_string_to_bytes(clean_hex);
-        
-        let padded_bytes = pad_to_32_bytes(hex_bytes);
-        from_bcs::to_address(padded_bytes)
-    }
-
-    /// Converts an address to a hex string with 0x prefix
-    public fun address_to_hex_string(addr: address): String {
-        let addr_bytes = bcs::to_bytes(&addr);
-        let hex_str = bytes_to_hex_string(addr_bytes);
-        let prefix = b"0x";
-        let hex_bytes = string::bytes(&hex_str);
-        vector::append(&mut prefix, *hex_bytes);
-        string::utf8(prefix)
-    }
-
     /// Converts bytes to a hex string (lowercase)
     public fun bytes_to_hex_string(bytes: vector<u8>): String {
         let hex_chars = b"0123456789abcdef";
@@ -94,66 +64,26 @@ module oapp::utils {
         string::utf8(result)
     }
 
-    /// Helper function to strip 0x or 0X prefix from hex string
-    fun strip_hex_prefix(hex_str: String): String {
-        let bytes = string::bytes(&hex_str);
-        let len = vector::length(bytes);
-        
-        if (len >= 2) {
-            let first = *vector::borrow(bytes, 0);
-            let second = *vector::borrow(bytes, 1);
-            
-            if (first == 48 && (second == 120 || second == 88)) {
-                let remaining = vector::empty<u8>();
-                let i = 2;
-                while (i < len) {
-                    vector::push_back(&mut remaining, *vector::borrow(bytes, i));
-                    i = i + 1;
-                };
-                return string::utf8(remaining)
-            }
-        };
-        
-        hex_str
-    }
-
-    /// Helper function to pad bytes to 32 bytes (left-padded with zeros)
-    fun pad_to_32_bytes(bytes: vector<u8>): vector<u8> {
-        let len = vector::length(&bytes);
-        assert!(len <= 32, EINVALID_ADDRESS_LENGTH);
-        
-        if (len == 32) {
-            return bytes
-        };
-        
-        let result = vector::empty<u8>();
-        let padding_needed = 32 - len;
-        let i = 0;
-        
-        while (i < padding_needed) {
-            vector::push_back(&mut result, 0);
-            i = i + 1;
-        };
-        
-        vector::append(&mut result, bytes);
-        result
-    }
-
     /// Helper function to convert a hex character to u8
     fun hex_char_to_u8(char: u8): u8 {
-        if (char >= 48 && char <= 57) {
-            char - 48
-        } else if (char >= 65 && char <= 70) {
-            char - 65 + 10
-        } else if (char >= 97 && char <= 102) {
-            char - 97 + 10
+        if (char >= ASCII_ZERO && char <= ASCII_NINE) {
+            char - ASCII_ZERO
+        } else if (char >= ASCII_UPPERCASE_A && char <= ASCII_UPPERCASE_F) {
+            char - ASCII_UPPERCASE_A + 10
+        } else if (char >= ASCII_LOWERCASE_A && char <= ASCII_LOWERCASE_F) {
+            char - ASCII_LOWERCASE_A + 10
         } else {
             abort EINVALID_HEX_CHARACTER
         }
     }
 
-    const EINVALID_LENGTH: u64 = 1;
-    const EINVALID_HEX_LENGTH: u64 = 2;
-    const EINVALID_HEX_CHARACTER: u64 = 3;
-    const EINVALID_ADDRESS_LENGTH: u64 = 4;
+    const ASCII_ZERO: u8 = 48;
+    const ASCII_NINE: u8 = 57;
+    const ASCII_UPPERCASE_A: u8 = 65;
+    const ASCII_UPPERCASE_F: u8 = 70;
+    const ASCII_LOWERCASE_A: u8 = 97;
+    const ASCII_LOWERCASE_F: u8 = 102;
+    
+    const EINVALID_HEX_CHARACTER: u64 = 1;
+    const EINVALID_ADDRESS_LENGTH: u64 = 2;
 } 

examples/oapp-aptos-move/tests/oapp_tests.move

@@ -0,0 +1,42 @@
+#[test_only]
+module oapp::oapp_tests {
+    use std::string;
+    use std::vector;
+    use aptos_std::from_bcs;
+    use oapp::utils::hex_string_to_bytes;
+    use oapp::oapp::parse_message;
+
+    #[test]
+    fun test_parse_message() {
+        let expected_addr1 = @0x1234567890123456789012345678901234567890;
+        let expected_addr2 = @0x9876543210987654321098765432109876543210;
+        let expected_number: u256 = 123456789012345678901234567890;
+
+        let encoded_data = x"000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000c23078303030303030303030303030303030303030303030303030313233343536373839303132333435363738393031323334353637383930313233343536373839303030303030303030303030303030303030303030303030303938373635343332313039383736353433323130393837363534333231303938373635343332313030303030303030303030303030303030303030303030303030303030303030303030303030303031386565393066663663333733653065653465336630616432000000000000000000000000000000000000000000000000000000000000";
+
+        let (actual_addr1, actual_addr2, actual_number) = parse_message(encoded_data);
+
+        assert!(actual_addr1 == expected_addr1, 1);
+        assert!(actual_addr2 == expected_addr2, 2);
+        assert!(actual_number == expected_number, 3);
+    }
+
+    #[test]
+    fun test_parse_message_with_prefix() {
+        let expected_addr1 = @0x58b730d07e98a22f2b357bee721115c986e4dc873c1884763708ee3d4006f74e;
+        let expected_addr2 = @0x58b730d07e98a22f2b357bee721115c986e4dc873c1884763708ee3d4006f74e;
+        let expected_number: u256 = 123456789012345678901234567890;
+
+        let encoded_data = x"000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000c23078353862373330643037653938613232663262333537626565373231313135633938366534646338373363313838343736333730386565336434303036663734653538623733306430376539386132326632623335376265653732313131356339383665346463383733633138383437363337303865653364343030366637346530303030303030303030303030303030303030303030303030303030303030303030303030303031386565393066663663333733653065653465336630616432000000000000000000000000000000000000000000000000000000000000";
+
+        let (actual_addr1, actual_addr2, actual_number) = parse_message(encoded_data);
+
+        std::debug::print(&actual_addr1);
+        std::debug::print(&actual_addr2);
+        std::debug::print(&actual_number);
+
+        assert!(actual_addr1 == expected_addr1, 1);
+        assert!(actual_addr2 == expected_addr2, 2);
+        assert!(actual_number == expected_number, 3);
+    }
+}