Merge pull request #386 from TheBlueMatt/2019-10-useless-lints

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

diff --git a/src/util/ser.rs b/src/util/ser.rs
index 575d4668d641875acf4df6a7212aca823e13f9c6..a2ef16b5e2462c51dd22f7c4444cd0cf7b22460a 100644 (file)
--- a/src/util/ser.rs
+++ b/src/util/ser.rs
@@ -6,10 +6,11 @@ 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;
+use bitcoin::blockdata::transaction::OutPoint;
+use bitcoin_hashes::sha256d::Hash as Sha256dHash;
 use std::marker::Sized;
 use ln::msgs::DecodeError;
 use ln::channelmanager::{PaymentPreimage, PaymentHash};
@@ -315,7 +316,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),
                }
@@ -333,7 +334,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),
                }
@@ -342,27 +343,29 @@ impl<R: Read> Readable<R> for SecretKey {
 
 impl Writeable for Sha256dHash {
        fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
-               self.as_bytes().write(w)
+               w.write_all(&self[..])
        }
 }
 
 impl<R: Read> Readable<R> for Sha256dHash {
        fn read(r: &mut R) -> Result<Self, DecodeError> {
+               use bitcoin_hashes::Hash;
+
                let buf: [u8; 32] = Readable::read(r)?;
-               Ok(From::from(&buf[..]))
+               Ok(Sha256dHash::from_slice(&buf[..]).unwrap())
        }
 }
 
 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),
                }
@@ -420,3 +423,22 @@ impl<R, T> Readable<R> for Option<T>
                }
        }
 }
+
+impl Writeable for OutPoint {
+       fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
+               self.txid.write(w)?;
+               self.vout.write(w)?;
+               Ok(())
+       }
+}
+
+impl<R: Read> Readable<R> for OutPoint {
+       fn read(r: &mut R) -> Result<Self, DecodeError> {
+               let txid = Readable::read(r)?;
+               let vout = Readable::read(r)?;
+               Ok(OutPoint {
+                       txid,
+                       vout,
+               })
+       }
+}