nour 1.0.0

High-performance Bitcoin SV toolkit for transactions, scripts, P2P, and wallets
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

//! Binary serialization/deserialization trait for Bitcoin SV objects.
use crate::util::{Error, Result};
use std::io;
use std::io::{Read, Write};
#[cfg(feature = "async")]
use tokio::io::{AsyncRead, AsyncWrite};

/// An object that may be serialized and deserialized.
pub trait Serializable<T> {
    /// Reads the object from serialized form.
    ///
    /// # Errors
    /// Propagates IO errors or invalid data.
    fn read(reader: &mut dyn Read) -> Result<T>
    where
        Self: Sized;
    /// Writes the object to the object to serialized form.
    ///
    /// # Errors
    /// IO errors.
    fn write(&self, writer: &mut dyn Write) -> io::Result<()>;
}

#[cfg(feature = "async")]
pub trait AsyncSerializable<T> {
    /// Reads the object from serialized form asynchronously.
    ///
    /// # Errors
    /// Propagates IO errors or invalid data.
    async fn read_async(reader: &mut dyn AsyncRead) -> Result<T>
    where
        Self: Sized;
    /// Writes the object to serialized form asynchronously.
    ///
    /// # Errors
    /// IO errors.
    async fn write_async(&self, writer: &mut dyn AsyncWrite) -> io::Result<()>;
}

impl Serializable<[u8; 16]> for [u8; 16] {
    fn read(reader: &mut dyn Read) -> Result<[u8; 16]> {
        let mut d = [0; 16];
        reader.read_exact(&mut d).map_err(|e| Error::IOError(e))?;
        Ok(d)
    }
    fn write(&self, writer: &mut dyn Write) -> io::Result<()> {
        writer.write_all(self)
    }
}

impl Serializable<[u8; 32]> for [u8; 32] {
    fn read(reader: &mut dyn Read) -> Result<[u8; 32]> {
        let mut d = [0; 32];
        reader.read_exact(&mut d).map_err(|e| Error::IOError(e))?;
        Ok(d)
    }
    fn write(&self, writer: &mut dyn Write) -> io::Result<()> {
        writer.write_all(self)
    }
}

#[cfg(feature = "async")]
impl AsyncSerializable<[u8; 16]> for [u8; 16] {
    async fn read_async(reader: &mut dyn AsyncRead) -> Result<[u8; 16]> {
        // Use tokio read_exact impl
        let mut d = [0; 16];
        reader
            .read_exact(&mut d)
            .await
            .map_err(|e| Error::IOError(e))?;
        Ok(d)
    }
    async fn write_async(&self, writer: &mut dyn AsyncWrite) -> io::Result<()> {
        writer.write_all(self).await
    }
}

#[cfg(feature = "async")]
impl AsyncSerializable<[u8; 32]> for [u8; 32] {
    async fn read_async(reader: &mut dyn AsyncRead) -> Result<[u8; 32]> {
        let mut d = [0; 32];
        reader
            .read_exact(&mut d)
            .await
            .map_err(|e| Error::IOError(e))?;
        Ok(d)
    }
    async fn write_async(&self, writer: &mut dyn AsyncWrite) -> io::Result<()> {
        writer.write_all(self).await
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use byteorder::{LittleEndian, ReadBytesExt};
    use pretty_assertions::assert_eq;
    use std::io::Cursor;

    #[test]
    fn test_serdes_array16() -> Result<()> {
        let array = [1; 16];
        let mut v = Vec::new();
        array.write(&mut v)?;
        let deserialized = <[u8; 16]>::read(&mut Cursor::new(&v))?;
        assert_eq!(array, deserialized);
        Ok(())
    }

    #[test]
    fn test_serdes_array32() -> Result<()> {
        let array = [2; 32];
        let mut v = Vec::new();
        array.write(&mut v)?;
        let deserialized = <[u8; 32]>::read(&mut Cursor::new(&v))?;
        assert_eq!(array, deserialized);
        Ok(())
    }

    #[test]
    fn test_short_read() {
        use std::io::Cursor;
        let short_bytes = vec![0u8; 3]; // For read_u32 expecting 4
        let mut ser = Cursor::new(short_bytes);
        assert_eq!(
            ser.read_u32::<LittleEndian>().unwrap_err().to_string(),
            "failed to fill whole buffer"
        );
    }
}