Merge pull request #298 from TheBlueMatt/2019-01-271-cleanup

[rust-lightning] / src / util / ser.rs

diff --git a/src/util/ser.rs b/src/util/ser.rs
index c1d2802a76da834d03555cf73b0e2f88139d52a5..d832c7018825e75df028bd2e2b8ea538962cc0e3 100644 (file)
--- a/src/util/ser.rs
+++ b/src/util/ser.rs
@@ -6,7 +6,7 @@ use std::io::{Read, Write};
 use std::collections::HashMap;
 use std::hash::Hash;
 
-use secp256k1::{Secp256k1, Signature};
+use secp256k1::Signature;
 use secp256k1::key::{PublicKey, SecretKey};
 use bitcoin::util::hash::Sha256dHash;
 use bitcoin::blockdata::script::Script;
@@ -203,6 +203,10 @@ macro_rules! impl_array {
 }
 
 //TODO: performance issue with [u8; size] with impl_array!()
+impl_array!(3); // for rgb
+impl_array!(4); // for IPv4
+impl_array!(10); // for OnionV2
+impl_array!(16); // for IPv6
 impl_array!(32); // for channel id & hmac
 impl_array!(33); // for PublicKey
 impl_array!(64); // for Signature
@@ -302,29 +306,6 @@ impl<R: Read> Readable<R> for Script {
        }
 }
 
-impl Writeable for Option<Script> {
-       fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
-               if let &Some(ref script) = self {
-                       script.write(w)?;
-               }
-               Ok(())
-       }
-}
-
-impl<R: Read> Readable<R> for Option<Script> {
-       fn read(r: &mut R) -> Result<Self, DecodeError> {
-               match <u16 as Readable<R>>::read(r) {
-                       Ok(len) => {
-                               let mut buf = vec![0; len as usize];
-                               r.read_exact(&mut buf)?;
-                               Ok(Some(Script::from(buf)))
-                       },
-                       Err(DecodeError::ShortRead) => Ok(None),
-                       Err(e) => Err(e)
-               }
-       }
-}
-
 impl Writeable for PublicKey {
        fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
                self.serialize().write(w)
@@ -334,7 +315,7 @@ impl Writeable for PublicKey {
 impl<R: Read> Readable<R> for PublicKey {
        fn read(r: &mut R) -> Result<Self, DecodeError> {
                let buf: [u8; 33] = Readable::read(r)?;
-               match PublicKey::from_slice(&Secp256k1::without_caps(), &buf) {
+               match PublicKey::from_slice(&buf) {
                        Ok(key) => Ok(key),
                        Err(_) => return Err(DecodeError::InvalidValue),
                }
@@ -352,7 +333,7 @@ impl Writeable for SecretKey {
 impl<R: Read> Readable<R> for SecretKey {
        fn read(r: &mut R) -> Result<Self, DecodeError> {
                let buf: [u8; 32] = Readable::read(r)?;
-               match SecretKey::from_slice(&Secp256k1::without_caps(), &buf) {
+               match SecretKey::from_slice(&buf) {
                        Ok(key) => Ok(key),
                        Err(_) => return Err(DecodeError::InvalidValue),
                }
@@ -374,14 +355,14 @@ impl<R: Read> Readable<R> for Sha256dHash {
 
 impl Writeable for Signature {
        fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
-               self.serialize_compact(&Secp256k1::without_caps()).write(w)
+               self.serialize_compact().write(w)
        }
 }
 
 impl<R: Read> Readable<R> for Signature {
        fn read(r: &mut R) -> Result<Self, DecodeError> {
                let buf: [u8; 64] = Readable::read(r)?;
-               match Signature::from_compact(&Secp256k1::without_caps(), &buf) {
+               match Signature::from_compact(&buf) {
                        Ok(sig) => Ok(sig),
                        Err(_) => return Err(DecodeError::InvalidValue),
                }
@@ -413,3 +394,29 @@ impl<R: Read> Readable<R> for PaymentHash {
                Ok(PaymentHash(buf))
        }
 }
+
+impl<T: Writeable> Writeable for Option<T> {
+       fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+               match *self {
+                       None => 0u8.write(w)?,
+                       Some(ref data) => {
+                               1u8.write(w)?;
+                               data.write(w)?;
+                       }
+               }
+               Ok(())
+       }
+}
+
+impl<R, T> Readable<R> for Option<T>
+       where R: Read,
+             T: Readable<R>
+{
+       fn read(r: &mut R) -> Result<Self, DecodeError> {
+               match <u8 as Readable<R>>::read(r)? {
+                       0 => Ok(None),
+                       1 => Ok(Some(Readable::read(r)?)),
+                       _ => return Err(DecodeError::InvalidValue),
+               }
+       }
+}