use std::hash::Hasher;
use crate::codec::{CodecError, NeoSerializable};
use serde::Deserialize;
/// A binary encoder that can write various primitive types and serializable objects to a byte vector.
///
/// # Examples
///
/// ```
///
/// use neo3::neo_codec::Encoder;
/// let mut encoder = Encoder::new();
/// encoder.write_u8(0x12);
/// encoder.write_i32(-123456);
/// encoder.write_var_string("hello");
/// let bytes = encoder.to_bytes();
/// // Note: Actual output may vary depending on variable-length encoding
/// assert_eq!(bytes.len(), 11); // Just verify length instead of exact bytes
/// ```
use serde::Serialize;
#[derive(Debug, Clone, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub struct Encoder {
data: Vec<u8>,
}
impl Default for Encoder {
fn default() -> Self {
Self::new()
}
}
impl Encoder {
pub fn new() -> Self {
Self { data: Vec::new() }
}
pub fn size(&self) -> usize {
self.data.len()
}
pub fn write_bool(&mut self, value: bool) {
self.write_u8(if value { 1 } else { 0 });
}
pub fn write_u8(&mut self, value: u8) {
self.data.push(value);
}
pub fn write_i16(&mut self, v: i16) {
self.write_u16(v as u16);
}
pub fn write_i32(&mut self, v: i32) {
self.write_u32(v as u32);
}
pub fn write_i64(&mut self, v: i64) {
self.data.extend_from_slice(&v.to_le_bytes());
}
pub fn write_u16(&mut self, v: u16) {
self.data.extend_from_slice(&v.to_le_bytes());
}
pub fn write_u32(&mut self, v: u32) {
self.data.extend_from_slice(&v.to_le_bytes());
}
pub fn write_u64(&mut self, v: u64) {
self.data.extend_from_slice(&v.to_le_bytes());
}
pub fn write_bytes(&mut self, bytes: &[u8]) {
self.data.extend_from_slice(bytes);
}
pub fn write_var_int(&mut self, value: i64) -> Result<(), std::io::Error> {
if value < 0 {
return Err(std::io::Error::new(
std::io::ErrorKind::InvalidInput,
"Negative value not allowed for variable integer encoding",
));
}
let value = value as u64;
if value < 0xFD {
self.write_u8(value as u8);
} else if value <= 0xFFFF {
self.write_u8(0xFD);
self.write_u16(value as u16);
} else if value <= 0xFFFFFFFF {
self.write_u8(0xFE);
self.write_u32(value as u32);
} else {
self.write_u8(0xFF);
self.write_u64(value);
}
Ok(())
}
pub fn write_var_string(&mut self, v: &str) {
if let Err(e) = self.write_var_bytes(v.as_bytes()) {
tracing::warn!(error = %e, "Failed to serialize string; encoding as empty");
let _ = self.write_var_bytes(&[]);
}
}
pub fn write_fixed_string(
&mut self,
v: &Option<String>,
length: usize,
) -> Result<(), CodecError> {
let bytes = v.as_deref().unwrap_or_default().as_bytes();
if bytes.len() > length {
return Err(CodecError::InvalidEncoding("String too long".to_string()));
}
let mut padded = vec![0; length];
padded[0..bytes.len()].copy_from_slice(bytes);
self.write_bytes(&padded);
Ok(())
}
pub fn write_var_bytes(&mut self, bytes: &[u8]) -> Result<(), std::io::Error> {
self.write_var_int(bytes.len() as i64)?;
self.write_bytes(bytes);
Ok(())
}
pub fn write_serializable_fixed<S: NeoSerializable>(&mut self, value: &S) {
value.encode(self);
}
pub fn write_serializable_list_fixed<S: NeoSerializable>(&mut self, value: &[S]) {
value.iter().for_each(|v| v.encode(self));
}
pub fn write_serializable_variable_bytes<S: NeoSerializable>(
&mut self,
values: &S,
) -> Result<(), std::io::Error> {
self.write_var_int(values.to_array().len() as i64)?;
values.encode(self);
Ok(())
}
pub fn write_serializable_variable_list<S: NeoSerializable>(
&mut self,
values: &[S],
) -> Result<(), std::io::Error> {
self.write_var_int(values.len() as i64)?;
self.write_serializable_list_fixed(values);
Ok(())
}
pub fn write_serializable_variable_list_bytes<S: NeoSerializable>(
&mut self,
values: &[S],
) -> Result<(), std::io::Error> {
let total_size: usize = values.iter().map(|item| item.to_array().len()).sum();
self.write_var_int(total_size as i64)?;
self.write_serializable_list_fixed(values);
Ok(())
}
pub fn reset(&mut self) {
self.data.clear();
}
pub fn to_bytes(&self) -> Vec<u8> {
self.data.clone()
}
}
impl Hasher for Encoder {
fn finish(&self) -> u64 {
// Return a hash of the encoder's data using a simple algorithm
// This implementation provides a basic hash for compatibility
let mut hash = 0u64;
for (i, &byte) in self.data.iter().enumerate() {
hash = hash.wrapping_mul(31).wrapping_add(byte as u64);
if i >= 8 {
break;
} // Limit to first 8 bytes for performance
}
hash
}
fn write(&mut self, bytes: &[u8]) {
self.write_bytes(bytes);
}
}
#[cfg(test)]
mod tests {
use crate::codec::Encoder;
#[test]
fn test_write_u32() {
let mut writer = Encoder::new();
let max = u32::MAX;
writer.write_u32(max);
assert_eq!(writer.to_bytes(), vec![0xff; 4]);
writer.reset();
writer.write_u32(0);
assert_eq!(writer.to_bytes(), vec![0; 4]);
writer.reset();
writer.write_u32(12345);
assert_eq!(writer.to_bytes(), vec![0x39, 0x30, 0, 0]);
}
#[test]
fn test_write_i64() {
let mut writer = Encoder::new();
writer.write_i64(0x1234567890123456i64);
assert_eq!(writer.to_bytes(), [0x56, 0x34, 0x12, 0x90, 0x78, 0x56, 0x34, 0x12]);
writer.reset();
writer.write_i64(i64::MAX);
assert_eq!(writer.to_bytes(), [0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x7f]);
writer.reset();
writer.write_i64(i64::MIN);
assert_eq!(writer.to_bytes(), [0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80]);
writer.reset();
writer.write_i64(0);
assert_eq!(writer.to_bytes(), vec![0u8; 8]);
writer.reset();
writer.write_i64(1234567890);
assert_eq!(writer.to_bytes(), vec![0xd2, 0x02, 0x96, 0x49, 0, 0, 0, 0]);
}
#[test]
fn test_write_u16() {
let mut writer = Encoder::new();
let max = u16::MAX;
writer.write_u16(max);
assert_eq!(writer.to_bytes(), vec![0xff; 2]);
writer.reset();
writer.write_u16(0);
assert_eq!(writer.to_bytes(), vec![0; 2]);
writer.reset();
writer.write_u16(12345);
assert_eq!(writer.to_bytes(), vec![0x39, 0x30]);
}
#[test]
fn test_write_var_int() {
let mut writer = Encoder::new();
writer.write_var_int(0).unwrap();
assert_eq!(writer.to_bytes(), vec![0]);
writer.reset();
writer.write_var_int(252).unwrap();
assert_eq!(writer.to_bytes(), vec![0xfc]);
writer.reset();
writer.write_var_int(253).unwrap();
assert_eq!(writer.to_bytes(), vec![0xfd, 0xfd, 0]);
writer.reset();
writer.write_var_int(65_534).unwrap();
assert_eq!(writer.to_bytes(), vec![0xfd, 0xfe, 0xff]);
writer.reset();
writer.write_var_int(65_536).unwrap();
assert_eq!(writer.to_bytes(), vec![0xfe, 0, 0, 1, 0]);
writer.reset();
writer.write_var_int(4_294_967_295).unwrap();
assert_eq!(writer.to_bytes(), vec![0xfe, 0xff, 0xff, 0xff, 0xff]);
writer.reset();
writer.write_var_int(4_294_967_296).unwrap();
assert_eq!(writer.to_bytes(), vec![0xff, 0, 0, 0, 0, 1, 0, 0, 0]);
}
#[test]
fn test_write_var_bytes() {
let mut writer = Encoder::new();
let bytes = hex::decode("010203").unwrap();
writer.write_var_bytes(&bytes).unwrap();
assert_eq!(writer.to_bytes(), hex::decode("03010203").unwrap());
writer.reset();
let bytes = "0010203010203010203010203010203010203010203010203010203010203010203102030102030102030102030102030102030102030102030102030102030102031020301020301020301020301020301020301020301020301020301020301020310203010203010203010203010203010203010203010203010203010203010203001020301020301020301020301020301020301020301020301020301020301020310203010203010203010203010203010203010203010203010203010203";
writer.write_var_bytes(&hex::decode(bytes).unwrap()).unwrap();
assert_eq!(writer.to_bytes(), hex::decode(format!("c2{}", bytes)).unwrap());
}
#[test]
fn test_write_var_string() {
let mut writer = Encoder::new();
let s = "hello, world!";
writer.write_var_string(s);
assert_eq!(writer.to_bytes(), hex::decode("0d68656c6c6f2c20776f726c6421").unwrap());
writer.reset();
let s = "hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!hello, world!";
writer.write_var_string(s);
assert_eq!(
writer.to_bytes(),
[hex::decode("fd1502").unwrap(), s.as_bytes().to_vec()].concat()
);
}
}