Add parsing tests to files

Author: Maxwell Dulin

sui/packages/wormhole_transceiver/sources/messages/wormhole_transceiver_info.move

@@ -0,0 +1,136 @@
+
+module wormhole_transceiver::wormhole_transceiver_info {
+    use wormhole::external_address::{Self,ExternalAddress};
+    use wormhole::bytes;
+    use wormhole::cursor::{Self, Cursor};
+    use ntt_common::bytes4::{Self};
+    use ntt::mode::{Self, Mode};
+
+    const INFO_PREFIX: vector<u8> = x"9C23BD3B";
+
+    #[error]
+    const EIncorrectPrefix: vector<u8>
+        = b"incorrect prefix";
+
+    // https://github.com/wormhole-foundation/native-token-transfers/blob/b6b681a77e8289869f35862b261b8048e3f5d398/evm/src/libraries/TransceiverStructs.sol#L409C12-L409C27
+    public struct WormholeTransceiverInfo has drop{
+        manager_address: ExternalAddress,
+        manager_mode: Mode, 
+        token_address: ExternalAddress,
+        token_decimals: u8
+    }
+
+    public(package) fun new(manager_address: ExternalAddress, mode: Mode, token_address: ExternalAddress, decimals: u8): WormholeTransceiverInfo{
+        WormholeTransceiverInfo {
+            manager_address: manager_address, 
+            manager_mode: mode, 
+            token_address: token_address, 
+            token_decimals: decimals
+        }
+    }
+
+    public fun to_bytes(self: &WormholeTransceiverInfo): vector<u8> {
+        let mut buf = vector::empty<u8>();
+
+        buf.append(INFO_PREFIX);
+        buf.append(self.manager_address.to_bytes()); // decimals and amount
+        buf.append(self.manager_mode.serialize()); // 32 bytes
+        buf.append(self.token_address.to_bytes()); // 32 bytes 
+        bytes::push_u8(&mut buf, self.token_decimals); // 2 bytes
+        buf
+    }
+
+    public fun take_bytes(cur: &mut Cursor<u8>): WormholeTransceiverInfo {
+        let ntt_prefix = bytes4::take(cur);
+        assert!(ntt_prefix.to_bytes() == INFO_PREFIX, EIncorrectPrefix);
+        let manager_address = external_address::take_bytes(cur);
+        let mode = mode::parse(bytes::take_bytes(cur, 1));
+        let token_address = external_address::take_bytes(cur);
+        let token_decimals = bytes::take_u8(cur);
+
+        WormholeTransceiverInfo {
+            manager_address: manager_address, 
+            manager_mode: mode, 
+            token_address: token_address, 
+            token_decimals: token_decimals
+        }
+    }
+
+    public fun parse(buf: vector<u8>): WormholeTransceiverInfo   {
+        let mut cur = cursor::new(buf);
+        let info  = take_bytes(&mut cur);
+        cur.destroy_empty();
+        info
+    }
+
+    #[test]
+    public fun test_round_trip() {
+        let reg = new(external_address::from_address(@102), mode::burning(), external_address::from_address(@304), 9);
+
+        let reg_bytes = reg.to_bytes();
+
+        let reg_round_trip = parse(reg_bytes);
+
+        assert!(reg.manager_address == reg_round_trip.manager_address);
+        assert!(reg.manager_mode == reg_round_trip.manager_mode);
+        assert!(reg.token_address == reg_round_trip.token_address);
+        assert!(reg.token_decimals == reg_round_trip.token_decimals);
+    }
+
+    #[test]
+    public fun test_raw_to_bytes() {
+        let mut raw_bytes = vector::empty<u8>();
+
+        let prefix = vector<u8>[0x9c, 0x23, 0xbd, 0x3b];
+        let manager_address = vector<u8>[0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2];
+        let mode = vector<u8>[0x1]; 
+
+        let token_address = vector<u8>[0x4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5];
+        let token_decimals = vector<u8>[0x3]; 
+
+        vector::append(&mut raw_bytes, prefix);
+        vector::append(&mut raw_bytes, manager_address);
+        vector::append(&mut raw_bytes, mode);
+        vector::append(&mut raw_bytes, token_address);
+        vector::append(&mut raw_bytes, token_decimals);
+
+
+        let reg = parse(raw_bytes); 
+
+        assert!(reg.manager_address.to_bytes() == manager_address);
+        assert!(reg.manager_mode == mode::burning());
+        assert!(reg.token_address.to_bytes() == token_address);
+        assert!(reg.token_decimals == 3);
+    }
+
+    #[test]
+    public fun test_reg_to_raw_bytes(){
+        let mut raw_bytes = vector::empty<u8>();
+
+
+        let prefix = vector<u8>[0x9c, 0x23, 0xbd, 0x3b];
+        let manager_address = vector<u8>[0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2];
+        let mode = vector<u8>[0x0]; 
+
+        let token_address = vector<u8>[0x4, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x5];
+        let token_decimals = vector<u8>[0x9]; 
+
+        vector::append(&mut raw_bytes, prefix);
+        vector::append(&mut raw_bytes, manager_address);
+        vector::append(&mut raw_bytes, mode);
+        vector::append(&mut raw_bytes, token_address);
+        vector::append(&mut raw_bytes, token_decimals);
+
+        // Create value
+        let reg = new(external_address::from_address(@0x0100000000000000000000000000000000000000000000000000000000000002), mode::locking(), external_address::from_address(@0x0400000000000000000000000000000000000000000000000000000000000005), 9);
+
+        assert!(reg.manager_address.to_bytes() == manager_address);
+        assert!(reg.manager_mode == mode::locking());
+        assert!(reg.token_address.to_bytes() == token_address);
+        assert!(reg.token_decimals == 9);
+
+        let derived = to_bytes(&reg);
+        assert!(derived == raw_bytes);
+    }
+
+}

sui/packages/wormhole_transceiver/sources/messages/wormhole_transceiver_registration.move

@@ -0,0 +1,103 @@
+
+module wormhole_transceiver::wormhole_transceiver_registration {
+    use wormhole::external_address::{Self,ExternalAddress};
+    use wormhole::bytes;
+    use wormhole::cursor::{Self, Cursor};
+    use ntt_common::bytes4::{Self};
+    const REGISTRATION_PREFIX: vector<u8> = x"18fc67c2";
+
+    #[error]
+    const EIncorrectPrefix: vector<u8>
+        = b"incorrect prefix";
+
+    // https://github.com/wormhole-foundation/native-token-transfers/blob/b6b681a77e8289869f35862b261b8048e3f5d398/evm/src/libraries/TransceiverStructs.sol#L441
+    public struct WormholeTransceiverRegistration has drop {
+        transceiver_chain_id: u16,
+        transceiver_address: ExternalAddress
+    }
+
+    public(package) fun new(transceiver_chain_id: u16, transceiver_address: ExternalAddress): WormholeTransceiverRegistration{
+        WormholeTransceiverRegistration {
+            transceiver_chain_id: transceiver_chain_id,
+            transceiver_address: transceiver_address
+        }
+    }
+
+    public fun to_bytes(self: &WormholeTransceiverRegistration): vector<u8> {
+        let mut buf = vector::empty<u8>();
+
+        buf.append(REGISTRATION_PREFIX);
+        bytes::push_u16_be(&mut buf, self.transceiver_chain_id);
+        buf.append(self.transceiver_address.to_bytes()); 
+        buf
+    }
+
+    public fun take_bytes(cur: &mut Cursor<u8>): WormholeTransceiverRegistration {
+        let ntt_prefix = bytes4::take(cur);
+        assert!(ntt_prefix.to_bytes() == REGISTRATION_PREFIX, EIncorrectPrefix);
+        let chain_id = bytes::take_u16_be(cur);
+        let transceiver_address = external_address::take_bytes(cur);
+
+        WormholeTransceiverRegistration {
+            transceiver_chain_id: chain_id, 
+            transceiver_address: transceiver_address
+        }
+    }
+
+    public fun parse(buf: vector<u8>): WormholeTransceiverRegistration   {
+        let mut cur = cursor::new(buf);
+        let reg  = take_bytes(&mut cur);
+        cur.destroy_empty();
+        reg
+    }
+
+    #[test]
+    public fun test_round_trip() {
+        let reg = new(1,external_address::from_address(@102));
+
+        let reg_bytes = reg.to_bytes();
+
+        let reg_round_trip = parse(reg_bytes);
+
+        assert!(reg.transceiver_address == reg_round_trip.transceiver_address);
+        assert!(reg.transceiver_chain_id == reg_round_trip.transceiver_chain_id);
+    }
+
+    #[test]
+    public fun test_raw_to_bytes() {
+        let mut raw_bytes = vector::empty<u8>();
+
+        let prefix = vector<u8>[0x18, 0xfc, 0x67, 0xc2];
+        let transceiver_address = vector<u8>[0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2];
+        let chain_id = vector<u8>[0x4, 0x56]; 
+        vector::append(&mut raw_bytes, prefix);
+        vector::append(&mut raw_bytes, chain_id);
+        vector::append(&mut raw_bytes, transceiver_address);
+
+        let reg = parse(raw_bytes); 
+
+        assert!(reg.transceiver_address.to_bytes() == transceiver_address);
+        assert!(reg.transceiver_chain_id == 0x456);
+    }
+
+    #[test]
+    public fun test_reg_to_raw_bytes(){
+        let mut raw_bytes = vector::empty<u8>();
+
+        // Test bytes
+        let prefix = vector<u8>[0x18, 0xfc, 0x67, 0xc2];
+        let transceiver_address = vector<u8>[0x1, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2];
+        let chain_id = vector<u8>[0x4, 0x56];
+        vector::append(&mut raw_bytes, prefix);
+        vector::append(&mut raw_bytes, chain_id);
+        vector::append(&mut raw_bytes, transceiver_address); 
+
+        // Create value
+        let reg = new(0x456,external_address::from_address(@0x0100000000000000000000000000000000000000000000000000000000000002));
+        assert!(reg.transceiver_address.to_bytes() == transceiver_address);
+        assert!(reg.transceiver_chain_id == 0x456);
+
+        let derived = to_bytes(&reg);
+        assert!(derived == raw_bytes);
+    }
+}

sui/packages/wormhole_transceiver/sources/wormhole_transceiver.move

@@ -140,12 +140,12 @@ module wormhole_transceiver::wormhole_transceiver {
 
         let external_address_manager_address = wormhole::external_address::from_address(manager_address);
 
-        let transceiver_info_struct = wormhole_transceiver::transceiver_structs::new_transceiver_info(external_address_manager_address, *manager_state.borrow_mode(),  wormhole::external_address::from_id(object::id(coin_meta)), coin_meta.get_decimals());
+        let transceiver_info_struct = wormhole_transceiver::wormhole_transceiver_info::new(external_address_manager_address, *manager_state.borrow_mode(),  wormhole::external_address::from_id(object::id(coin_meta)), coin_meta.get_decimals());
 
         let message_ticket = wormhole::publish_message::prepare_message(
             &mut state.emitter_cap,
             0,
-            transceiver_info_struct.transceiver_info_to_bytes(),
+            transceiver_info_struct.to_bytes(),
         );
         option::some(message_ticket)
     }
@@ -156,11 +156,11 @@ module wormhole_transceiver::wormhole_transceiver {
     */
     fun broadcast_peer(chain_id: u16, peer_address: ExternalAddress, state: &mut State): Option<MessageTicket>{
 
-        let transceiver_registration_struct = wormhole_transceiver::transceiver_structs::new_transceiver_registration(chain_id, peer_address);
+        let transceiver_registration_struct = wormhole_transceiver::wormhole_transceiver_registration::new(chain_id, peer_address);
         let message_ticket = wormhole::publish_message::prepare_message(
             &mut state.emitter_cap,
             0,
-            transceiver_registration_struct.transceiver_registration_to_bytes(),
+            transceiver_registration_struct.to_bytes(),
         );
         option::some(message_ticket) 
     }