diff --git a/Cargo.toml b/Cargo.toml
index b41d94e..0413b03 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -52,7 +52,7 @@ path = "src/lib.rs"
 
 [profile.release]
 lto = true
-strip = true
+# strip = true
 opt-level = 3
 
 [package.metadata.wasm-pack.profile.release]
diff --git a/benches/lib-bench.rs b/benches/lib-bench.rs
index 7f9fa5d..88ffdf4 100644
--- a/benches/lib-bench.rs
+++ b/benches/lib-bench.rs
@@ -18,10 +18,7 @@ fn soeprotocol_utils_benchmarks(c: &mut Criterion) {
     ]
     .to_vec();
     let wtr = vec![];
-    let mut data_packet = DataPacket {
-        data: data_to_pack,
-        sequence: 0,
-    };
+    let mut data_packet = DataPacket::new(data_to_pack, 0);
 
     c.bench_function("write_packet_data_crc", |b| {
         b.iter(|| write_packet_data(black_box(&mut wtr.to_owned()), black_box(&mut data_packet)))
@@ -31,10 +28,7 @@ fn soeprotocol_utils_benchmarks(c: &mut Criterion) {
     ]
     .to_vec();
     let wtr = vec![];
-    let mut data_packet = DataPacket {
-        data: data_to_pack,
-        sequence: 0,
-    };
+    let mut data_packet = DataPacket::new(data_to_pack, 0);
     c.bench_function("write_packet_data", |b| {
         b.iter(|| write_packet_data(black_box(&mut wtr.to_owned()), black_box(&mut data_packet)))
     });
@@ -485,16 +479,16 @@ fn rc4_benchmark(c: &mut Criterion) {
 }
 
 fn criterion_benchmark(c: &mut Criterion) {
-    crc_legacy_benchmark(c);
-    crc_benchmark(c);
-    utils_benchmark(c);
-    jooat_benchmark(c);
-    rc4_benchmark(c);
+    // crc_legacy_benchmark(c);
+    // crc_benchmark(c);
+    // utils_benchmark(c);
+    // jooat_benchmark(c);
+    // rc4_benchmark(c);
     soeprotocol_parse_benchmarks(c);
     soeprotocol_pack_benchmarks(c);
     soeprotocol_utils_benchmarks(c);
-    gatewayprotocol_parse_benchmarks(c);
-    gatewayprotocol_pack_benchmarks(c);
+    // gatewayprotocol_parse_benchmarks(c);
+    // gatewayprotocol_pack_benchmarks(c);
 }
 
 criterion_group!(benches, criterion_benchmark);
diff --git a/src/soeprotocol.rs b/src/soeprotocol.rs
index c9b5af3..3cbb1db 100644
--- a/src/soeprotocol.rs
+++ b/src/soeprotocol.rs
@@ -97,7 +97,7 @@ impl Soeprotocol {
             .write_u32::<BigEndian>(packet.udp_length)
             .unwrap_or_default();
         self.wtr.append(&mut u8_from_str_nul_utf8_unchecked(
-            packet.protocol.as_str(),
+            packet.get_protocol().as_str(),
         ));
         self.wtr.clone()
     }
@@ -223,22 +223,27 @@ impl Soeprotocol {
         serde_json::from_str(&packet_string)
     }
 
-    pub fn group_packets(&mut self, opcode: u16, packets: Vec<Vec<u8>>) -> Vec<u8> {
+    pub fn group_packets(&mut self, opcode: u16, packets: &Vec<Vec<u8>>) -> Vec<u8> {
         self.wtr.clear();
         self.wtr.write_u16::<BigEndian>(opcode).unwrap_or_default();
-        for mut packet in packets {
+        for packet in packets {
             write_data_length(&mut self.wtr, packet.len());
+            // FIXME: shitty clone
+            let mut packet = packet.clone();
             self.wtr.append(&mut packet);
         }
         self.wtr.clone()
     }
 
     pub fn pack_group_object(&mut self, group_packet: SubBasePackets) -> Vec<u8> {
-        self.group_packets(SoeOpcode::Group as u16, group_packet.sub_packets)
+        self.group_packets(SoeOpcode::Group as u16, group_packet.get_sub_packets())
     }
 
     pub fn pack_multi_object(&mut self, multi_packet: SubBasePackets) -> Vec<u8> {
-        self.group_packets(SoeOpcode::MultiPacket as u16, multi_packet.sub_packets)
+        self.group_packets(
+            SoeOpcode::MultiPacket as u16,
+            multi_packet.get_sub_packets(),
+        )
     }
 
     pub fn get_data_object(
@@ -328,7 +333,7 @@ impl Soeprotocol {
     }
 
     pub fn pack_ordered_packet(&mut self, data: Vec<u8>, sequence: u16) -> Vec<u8> {
-        self.pack_ordered_object(DataPacket { data, sequence })
+        self.pack_ordered_object(DataPacket::new(data, sequence))
     }
 
     pub fn pack_session_request(&mut self, packet: String) -> Vec<u8> {
@@ -353,12 +358,9 @@ impl Soeprotocol {
         udp_length: u32,
         protocol: String,
     ) -> Vec<u8> {
-        self.pack_session_request_object(SessionRequestPacket {
-            session_id,
-            crc_length,
-            udp_length,
-            protocol,
-        })
+        self.pack_session_request_object(SessionRequestPacket::new(
+            session_id, crc_length, udp_length, protocol,
+        ))
     }
 
     pub fn pack_session_reply(&mut self, packet: String) -> Vec<u8> {
@@ -463,7 +465,7 @@ impl Soeprotocol {
     }
 
     pub fn pack_data_packet(&mut self, data: Vec<u8>, sequence: u16) -> Vec<u8> {
-        self.pack_data_object(DataPacket { data, sequence })
+        self.pack_data_object(DataPacket::new(data, sequence))
     }
 
     pub fn pack_fragment_data(&mut self, packet: String) -> Vec<u8> {
@@ -481,7 +483,7 @@ impl Soeprotocol {
     }
 
     pub fn pack_fragment_data_packet(&mut self, data: Vec<u8>, sequence: u16) -> Vec<u8> {
-        self.pack_fragment_data_object(DataPacket { data, sequence })
+        self.pack_fragment_data_object(DataPacket::new(data, sequence))
     }
 
     pub fn pack_out_of_order(&mut self, packet: String) -> Vec<u8> {
diff --git a/src/soeprotocol_functions.rs b/src/soeprotocol_functions.rs
index bbe63d3..df3543a 100644
--- a/src/soeprotocol_functions.rs
+++ b/src/soeprotocol_functions.rs
@@ -91,7 +91,7 @@ pub fn extract_subpacket_data(
 pub fn write_packet_data(wtr: &mut Vec<u8>, data_packet: &mut DataPacket) {
     wtr.write_u16::<BigEndian>(data_packet.sequence)
         .unwrap_or_default();
-    wtr.append(&mut data_packet.data);
+    wtr.append(data_packet.get_data());
 }
 
 #[cfg(test)]
@@ -104,10 +104,7 @@ mod tests {
         ]
         .to_vec();
         let mut wtr = vec![];
-        let mut data_packet = super::DataPacket {
-            data: data_to_pack,
-            sequence: 0,
-        };
+        let mut data_packet = super::DataPacket::new(data_to_pack, 0);
         super::write_packet_data(&mut wtr, &mut data_packet);
         assert_eq!(
             wtr,
diff --git a/src/soeprotocol_packets_structs.rs b/src/soeprotocol_packets_structs.rs
index ed852d5..ab7e732 100644
--- a/src/soeprotocol_packets_structs.rs
+++ b/src/soeprotocol_packets_structs.rs
@@ -1,12 +1,39 @@
 use serde::{Deserialize, Serialize};
+use wasm_bindgen::prelude::*;
+#[wasm_bindgen]
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct SessionRequestPacket {
     pub session_id: u32,
     pub crc_length: u32,
     pub udp_length: u32,
-    pub protocol: String,
+    protocol: String,
+}
+#[wasm_bindgen]
+impl SessionRequestPacket {
+    #[wasm_bindgen(constructor)]
+    pub fn new(session_id: u32, crc_length: u32, udp_length: u32, protocol: String) -> Self {
+        Self {
+            session_id,
+            crc_length,
+            udp_length,
+            protocol,
+        }
+    }
+    pub fn get_session_id(&self) -> u32 {
+        self.session_id
+    }
+    pub fn get_crc_length(&self) -> u32 {
+        self.crc_length
+    }
+    pub fn get_udp_length(&self) -> u32 {
+        self.udp_length
+    }
+    pub fn get_protocol(&self) -> String {
+        self.protocol.clone()
+    }
 }
 
+#[wasm_bindgen]
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct SessionReplyPacket {
     pub session_id: u32,
@@ -15,7 +42,42 @@ pub struct SessionReplyPacket {
     pub encrypt_method: u16,
     pub udp_length: u32,
 }
+#[wasm_bindgen]
+impl SessionReplyPacket {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        session_id: u32,
+        crc_seed: u32,
+        crc_length: u8,
+        encrypt_method: u16,
+        udp_length: u32,
+    ) -> Self {
+        Self {
+            session_id,
+            crc_seed,
+            crc_length,
+            encrypt_method,
+            udp_length,
+        }
+    }
+    pub fn get_session_id(&self) -> u32 {
+        self.session_id
+    }
+    pub fn get_crc_seed(&self) -> u32 {
+        self.crc_seed
+    }
+    pub fn get_crc_length(&self) -> u8 {
+        self.crc_length
+    }
+    pub fn get_encrypt_method(&self) -> u16 {
+        self.encrypt_method
+    }
+    pub fn get_udp_length(&self) -> u32 {
+        self.udp_length
+    }
+}
 
+#[wasm_bindgen]
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct NetStatusReplyPacket {
     pub client_tick_count: u16,
@@ -26,6 +88,50 @@ pub struct NetStatusReplyPacket {
     pub server_packet_received: u64,
     pub unknown_field: u16,
 }
+#[wasm_bindgen]
+impl NetStatusReplyPacket {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        client_tick_count: u16,
+        server_tick_count: u32,
+        client_packet_sent: u64,
+        client_packet_received: u64,
+        server_packet_sent: u64,
+        server_packet_received: u64,
+        unknown_field: u16,
+    ) -> Self {
+        Self {
+            client_tick_count,
+            server_tick_count,
+            client_packet_sent,
+            client_packet_received,
+            server_packet_sent,
+            server_packet_received,
+            unknown_field,
+        }
+    }
+    pub fn get_client_tick_count(&self) -> u16 {
+        self.client_tick_count
+    }
+    pub fn get_server_tick_count(&self) -> u32 {
+        self.server_tick_count
+    }
+    pub fn get_client_packet_sent(&self) -> u64 {
+        self.client_packet_sent
+    }
+    pub fn get_client_packet_received(&self) -> u64 {
+        self.client_packet_received
+    }
+    pub fn get_server_packet_sent(&self) -> u64 {
+        self.server_packet_sent
+    }
+    pub fn get_server_packet_received(&self) -> u64 {
+        self.server_packet_received
+    }
+    pub fn get_unknown_field(&self) -> u16 {
+        self.unknown_field
+    }
+}
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct MultiPackablePacket {
@@ -37,16 +143,44 @@ pub struct MultiPackablePacket {
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone)]
+#[wasm_bindgen]
 pub struct DataPacket {
-    pub data: Vec<u8>,
+    data: Vec<u8>,
     pub sequence: u16,
 }
+#[wasm_bindgen]
+impl DataPacket {
+    #[wasm_bindgen(constructor)]
+    pub fn new(data: Vec<u8>, sequence: u16) -> Self {
+        Self { data, sequence }
+    }
+    pub fn get_sequence(&self) -> u16 {
+        self.sequence
+    }
+}
+impl DataPacket {
+    pub fn get_data(&mut self) -> &mut Vec<u8> {
+        &mut self.data
+    }
+}
 
+#[wasm_bindgen]
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct AckPacket {
     pub sequence: u16,
 }
+#[wasm_bindgen]
+impl AckPacket {
+    #[wasm_bindgen(constructor)]
+    pub fn new(sequence: u16) -> Self {
+        Self { sequence }
+    }
+    pub fn get_sequence(&self) -> u16 {
+        self.sequence
+    }
+}
 
+#[wasm_bindgen]
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct NetStatusRequestPacket {
     pub client_tick_count: u16,
@@ -59,17 +193,112 @@ pub struct NetStatusRequestPacket {
     pub packets_received: u64,
     pub unknown_field: u16,
 }
+#[wasm_bindgen]
+impl NetStatusRequestPacket {
+    #[wasm_bindgen(constructor)]
+    pub fn new(
+        client_tick_count: u16,
+        last_client_update: u32,
+        average_update: u32,
+        shortest_update: u32,
+        longest_update: u32,
+        last_server_update: u32,
+        packets_sent: u64,
+        packets_received: u64,
+        unknown_field: u16,
+    ) -> Self {
+        Self {
+            client_tick_count,
+            last_client_update,
+            average_update,
+            shortest_update,
+            longest_update,
+            last_server_update,
+            packets_sent,
+            packets_received,
+            unknown_field,
+        }
+    }
+    pub fn get_client_tick_count(&self) -> u16 {
+        self.client_tick_count
+    }
+    pub fn get_last_client_update(&self) -> u32 {
+        self.last_client_update
+    }
+    pub fn get_average_update(&self) -> u32 {
+        self.average_update
+    }
+    pub fn get_shortest_update(&self) -> u32 {
+        self.shortest_update
+    }
+    pub fn get_longest_update(&self) -> u32 {
+        self.longest_update
+    }
+    pub fn get_last_server_update(&self) -> u32 {
+        self.last_server_update
+    }
+    pub fn get_packets_sent(&self) -> u64 {
+        self.packets_sent
+    }
+    pub fn get_packets_received(&self) -> u64 {
+        self.packets_received
+    }
+    pub fn get_unknown_field(&self) -> u16 {
+        self.unknown_field
+    }
+}
 
+#[wasm_bindgen]
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct SubBasePacket {
-    pub name: String,
+    name: String,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub sequence: Option<u16>,
     #[serde(skip_serializing_if = "Option::is_none")]
-    pub data: Option<Vec<u8>>,
+    data: Option<Vec<u8>>,
+}
+#[wasm_bindgen]
+impl SubBasePacket {
+    #[wasm_bindgen(constructor)]
+    pub fn new(name: String, sequence: Option<u16>, data: Option<Vec<u8>>) -> Self {
+        Self {
+            name,
+            sequence,
+            data,
+        }
+    }
+    pub fn get_name(&self) -> String {
+        self.name.clone()
+    }
+    pub fn get_sequence(&self) -> Option<u16> {
+        self.sequence
+    }
+}
+impl SubBasePacket {
+    pub fn get_data(&self) -> &Option<Vec<u8>> {
+        &self.data
+    }
 }
 
+#[wasm_bindgen]
 #[derive(Serialize, Deserialize, Debug, Clone)]
 pub struct SubBasePackets {
-    pub sub_packets: Vec<Vec<u8>>,
+    sub_packets: Vec<Vec<u8>>,
+}
+#[wasm_bindgen]
+impl SubBasePackets {
+    #[wasm_bindgen(constructor)]
+    pub fn new() -> Self {
+        Self {
+            sub_packets: Vec::new(),
+        }
+    }
+}
+impl SubBasePackets {
+    pub fn add_sub_packet(&mut self, sub_packet: Vec<u8>) {
+        self.sub_packets.push(sub_packet);
+    }
+    pub fn get_sub_packets(&self) -> &Vec<Vec<u8>> {
+        &self.sub_packets
+    }
 }