git.bitcoin.ninja Git - rust-lightning/blob - lightning/src/util/ser.rs

   1 // This file is Copyright its original authors, visible in version control
   2 // history.
   3 //
   4 // This file is licensed under the Apache License, Version 2.0 <LICENSE-APACHE
   5 // or http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   6 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your option.
   7 // You may not use this file except in accordance with one or both of these
   8 // licenses.
   9
  10 //! A very simple serialization framework which is used to serialize/deserialize messages as well
  11 //! as ChannelsManagers and ChannelMonitors.
  12
  13 use prelude::*;
  14 use std::io::{Read, Write};
  15 use std::collections::HashMap;
  16 use core::hash::Hash;
  17 use std::sync::Mutex;
  18 use core::cmp;
  19
  20 use bitcoin::secp256k1::Signature;
  21 use bitcoin::secp256k1::key::{PublicKey, SecretKey};
  22 use bitcoin::secp256k1::constants::{PUBLIC_KEY_SIZE, COMPACT_SIGNATURE_SIZE};
  23 use bitcoin::blockdata::script::Script;
  24 use bitcoin::blockdata::transaction::{OutPoint, Transaction, TxOut};
  25 use bitcoin::consensus;
  26 use bitcoin::consensus::Encodable;
  27 use bitcoin::hashes::sha256d::Hash as Sha256dHash;
  28 use bitcoin::hash_types::{Txid, BlockHash};
  29 use core::marker::Sized;
  30 use ln::msgs::DecodeError;
  31 use ln::{PaymentPreimage, PaymentHash, PaymentSecret};
  32
  33 use util::byte_utils::{be48_to_array, slice_to_be48};
  34
  35 /// serialization buffer size
  36 pub const MAX_BUF_SIZE: usize = 64 * 1024;
  37
  38 /// A trait that is similar to std::io::Write but has one extra function which can be used to size
  39 /// buffers being written into.
  40 /// An impl is provided for any type that also impls std::io::Write which simply ignores size
  41 /// hints.
  42 ///
  43 /// (C-not exported) as we only export serialization to/from byte arrays instead
  44 pub trait Writer {
  45         /// Writes the given buf out. See std::io::Write::write_all for more
  46         fn write_all(&mut self, buf: &[u8]) -> Result<(), ::std::io::Error>;
  47         /// Hints that data of the given size is about the be written. This may not always be called
  48         /// prior to data being written and may be safely ignored.
  49         fn size_hint(&mut self, size: usize);
  50 }
  51
  52 impl<W: Write> Writer for W {
  53         #[inline]
  54         fn write_all(&mut self, buf: &[u8]) -> Result<(), ::std::io::Error> {
  55                 <Self as ::std::io::Write>::write_all(self, buf)
  56         }
  57         #[inline]
  58         fn size_hint(&mut self, _size: usize) { }
  59 }
  60
  61 pub(crate) struct WriterWriteAdaptor<'a, W: Writer + 'a>(pub &'a mut W);
  62 impl<'a, W: Writer + 'a> Write for WriterWriteAdaptor<'a, W> {
  63         #[inline]
  64         fn write_all(&mut self, buf: &[u8]) -> Result<(), ::std::io::Error> {
  65                 self.0.write_all(buf)
  66         }
  67         #[inline]
  68         fn write(&mut self, buf: &[u8]) -> Result<usize, ::std::io::Error> {
  69                 self.0.write_all(buf)?;
  70                 Ok(buf.len())
  71         }
  72         #[inline]
  73         fn flush(&mut self) -> Result<(), ::std::io::Error> {
  74                 Ok(())
  75         }
  76 }
  77
  78 pub(crate) struct VecWriter(pub Vec<u8>);
  79 impl Writer for VecWriter {
  80         #[inline]
  81         fn write_all(&mut self, buf: &[u8]) -> Result<(), ::std::io::Error> {
  82                 self.0.extend_from_slice(buf);
  83                 Ok(())
  84         }
  85         #[inline]
  86         fn size_hint(&mut self, size: usize) {
  87                 self.0.reserve_exact(size);
  88         }
  89 }
  90
  91 /// Writer that only tracks the amount of data written - useful if you need to calculate the length
  92 /// of some data when serialized but don't yet need the full data.
  93 pub(crate) struct LengthCalculatingWriter(pub usize);
  94 impl Writer for LengthCalculatingWriter {
  95         #[inline]
  96         fn write_all(&mut self, buf: &[u8]) -> Result<(), ::std::io::Error> {
  97                 self.0 += buf.len();
  98                 Ok(())
  99         }
 100         #[inline]
 101         fn size_hint(&mut self, _size: usize) {}
 102 }
 103
 104 /// Essentially std::io::Take but a bit simpler and with a method to walk the underlying stream
 105 /// forward to ensure we always consume exactly the fixed length specified.
 106 pub(crate) struct FixedLengthReader<R: Read> {
 107         read: R,
 108         bytes_read: u64,
 109         total_bytes: u64,
 110 }
 111 impl<R: Read> FixedLengthReader<R> {
 112         pub fn new(read: R, total_bytes: u64) -> Self {
 113                 Self { read, bytes_read: 0, total_bytes }
 114         }
 115
 116         #[inline]
 117         pub fn bytes_remain(&mut self) -> bool {
 118                 self.bytes_read != self.total_bytes
 119         }
 120
 121         #[inline]
 122         pub fn eat_remaining(&mut self) -> Result<(), DecodeError> {
 123                 ::std::io::copy(self, &mut ::std::io::sink()).unwrap();
 124                 if self.bytes_read != self.total_bytes {
 125                         Err(DecodeError::ShortRead)
 126                 } else {
 127                         Ok(())
 128                 }
 129         }
 130 }
 131 impl<R: Read> Read for FixedLengthReader<R> {
 132         #[inline]
 133         fn read(&mut self, dest: &mut [u8]) -> Result<usize, ::std::io::Error> {
 134                 if self.total_bytes == self.bytes_read {
 135                         Ok(0)
 136                 } else {
 137                         let read_len = cmp::min(dest.len() as u64, self.total_bytes - self.bytes_read);
 138                         match self.read.read(&mut dest[0..(read_len as usize)]) {
 139                                 Ok(v) => {
 140                                         self.bytes_read += v as u64;
 141                                         Ok(v)
 142                                 },
 143                                 Err(e) => Err(e),
 144                         }
 145                 }
 146         }
 147 }
 148
 149 /// A Read which tracks whether any bytes have been read at all. This allows us to distinguish
 150 /// between "EOF reached before we started" and "EOF reached mid-read".
 151 pub(crate) struct ReadTrackingReader<R: Read> {
 152         read: R,
 153         pub have_read: bool,
 154 }
 155 impl<R: Read> ReadTrackingReader<R> {
 156         pub fn new(read: R) -> Self {
 157                 Self { read, have_read: false }
 158         }
 159 }
 160 impl<R: Read> Read for ReadTrackingReader<R> {
 161         #[inline]
 162         fn read(&mut self, dest: &mut [u8]) -> Result<usize, ::std::io::Error> {
 163                 match self.read.read(dest) {
 164                         Ok(0) => Ok(0),
 165                         Ok(len) => {
 166                                 self.have_read = true;
 167                                 Ok(len)
 168                         },
 169                         Err(e) => Err(e),
 170                 }
 171         }
 172 }
 173
 174 /// A trait that various rust-lightning types implement allowing them to be written out to a Writer
 175 ///
 176 /// (C-not exported) as we only export serialization to/from byte arrays instead
 177 pub trait Writeable {
 178         /// Writes self out to the given Writer
 179         fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error>;
 180
 181         /// Writes self out to a Vec<u8>
 182         fn encode(&self) -> Vec<u8> {
 183                 let mut msg = VecWriter(Vec::new());
 184                 self.write(&mut msg).unwrap();
 185                 msg.0
 186         }
 187
 188         /// Writes self out to a Vec<u8>
 189         fn encode_with_len(&self) -> Vec<u8> {
 190                 let mut msg = VecWriter(Vec::new());
 191                 0u16.write(&mut msg).unwrap();
 192                 self.write(&mut msg).unwrap();
 193                 let len = msg.0.len();
 194                 msg.0[..2].copy_from_slice(&(len as u16 - 2).to_be_bytes());
 195                 msg.0
 196         }
 197
 198         /// Gets the length of this object after it has been serialized. This can be overridden to
 199         /// optimize cases where we prepend an object with its length.
 200         // Note that LLVM optimizes this away in most cases! Check that it isn't before you override!
 201         #[inline]
 202         fn serialized_length(&self) -> usize {
 203                 let mut len_calc = LengthCalculatingWriter(0);
 204                 self.write(&mut len_calc).expect("No in-memory data may fail to serialize");
 205                 len_calc.0
 206         }
 207 }
 208
 209 impl<'a, T: Writeable> Writeable for &'a T {
 210         fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> { (*self).write(writer) }
 211 }
 212
 213 /// A trait that various rust-lightning types implement allowing them to be read in from a Read
 214 ///
 215 /// (C-not exported) as we only export serialization to/from byte arrays instead
 216 pub trait Readable
 217         where Self: Sized
 218 {
 219         /// Reads a Self in from the given Read
 220         fn read<R: Read>(reader: &mut R) -> Result<Self, DecodeError>;
 221 }
 222
 223 /// A trait that various higher-level rust-lightning types implement allowing them to be read in
 224 /// from a Read given some additional set of arguments which is required to deserialize.
 225 ///
 226 /// (C-not exported) as we only export serialization to/from byte arrays instead
 227 pub trait ReadableArgs<P>
 228         where Self: Sized
 229 {
 230         /// Reads a Self in from the given Read
 231         fn read<R: Read>(reader: &mut R, params: P) -> Result<Self, DecodeError>;
 232 }
 233
 234 /// A trait that various rust-lightning types implement allowing them to (maybe) be read in from a Read
 235 ///
 236 /// (C-not exported) as we only export serialization to/from byte arrays instead
 237 pub trait MaybeReadable
 238         where Self: Sized
 239 {
 240         /// Reads a Self in from the given Read
 241         fn read<R: Read>(reader: &mut R) -> Result<Option<Self>, DecodeError>;
 242 }
 243
 244 pub(crate) struct OptionDeserWrapper<T: Readable>(pub Option<T>);
 245 impl<T: Readable> Readable for OptionDeserWrapper<T> {
 246         #[inline]
 247         fn read<R: Read>(reader: &mut R) -> Result<Self, DecodeError> {
 248                 Ok(Self(Some(Readable::read(reader)?)))
 249         }
 250 }
 251
 252 pub(crate) struct U8Wrapper(pub u8);
 253 impl Writeable for U8Wrapper {
 254         #[inline(always)]
 255         fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
 256                 self.0.write(writer)
 257         }
 258 }
 259 impl Readable for U8Wrapper {
 260         #[inline(always)]
 261         fn read<R: Read>(reader: &mut R) -> Result<U8Wrapper, DecodeError> {
 262                 Ok(Self(Readable::read(reader)?))
 263         }
 264 }
 265
 266 const MAX_ALLOC_SIZE: u64 = 64*1024;
 267
 268 pub(crate) struct VecWriteWrapper<'a, T: Writeable>(pub &'a Vec<T>);
 269 impl<'a, T: Writeable> Writeable for VecWriteWrapper<'a, T> {
 270         #[inline]
 271         fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
 272                 (self.0.len() as u64).write(writer)?;
 273                 for ref v in self.0.iter() {
 274                         v.write(writer)?;
 275                 }
 276                 Ok(())
 277         }
 278 }
 279 pub(crate) struct VecReadWrapper<T: Readable>(pub Vec<T>);
 280 impl<T: Readable> Readable for VecReadWrapper<T> {
 281         #[inline]
 282         fn read<R: Read>(reader: &mut R) -> Result<Self, DecodeError> {
 283                 let count: u64 = Readable::read(reader)?;
 284                 let mut values = Vec::with_capacity(cmp::min(count, MAX_ALLOC_SIZE / (core::mem::size_of::<T>() as u64)) as usize);
 285                 for _ in 0..count {
 286                         match Readable::read(reader) {
 287                                 Ok(v) => { values.push(v); },
 288                                 Err(e) => return Err(e),
 289                         }
 290                 }
 291                 Ok(Self(values))
 292         }
 293 }
 294
 295 pub(crate) struct U48(pub u64);
 296 impl Writeable for U48 {
 297         #[inline]
 298         fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
 299                 writer.write_all(&be48_to_array(self.0))
 300         }
 301 }
 302 impl Readable for U48 {
 303         #[inline]
 304         fn read<R: Read>(reader: &mut R) -> Result<U48, DecodeError> {
 305                 let mut buf = [0; 6];
 306                 reader.read_exact(&mut buf)?;
 307                 Ok(U48(slice_to_be48(&buf)))
 308         }
 309 }
 310
 311 /// Lightning TLV uses a custom variable-length integer called BigSize. It is similar to Bitcoin's
 312 /// variable-length integers except that it is serialized in big-endian instead of little-endian.
 313 ///
 314 /// Like Bitcoin's variable-length integer, it exhibits ambiguity in that certain values can be
 315 /// encoded in several different ways, which we must check for at deserialization-time. Thus, if
 316 /// you're looking for an example of a variable-length integer to use for your own project, move
 317 /// along, this is a rather poor design.
 318 pub(crate) struct BigSize(pub u64);
 319 impl Writeable for BigSize {
 320         #[inline]
 321         fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
 322                 match self.0 {
 323                         0...0xFC => {
 324                                 (self.0 as u8).write(writer)
 325                         },
 326                         0xFD...0xFFFF => {
 327                                 0xFDu8.write(writer)?;
 328                                 (self.0 as u16).write(writer)
 329                         },
 330                         0x10000...0xFFFFFFFF => {
 331                                 0xFEu8.write(writer)?;
 332                                 (self.0 as u32).write(writer)
 333                         },
 334                         _ => {
 335                                 0xFFu8.write(writer)?;
 336                                 (self.0 as u64).write(writer)
 337                         },
 338                 }
 339         }
 340 }
 341 impl Readable for BigSize {
 342         #[inline]
 343         fn read<R: Read>(reader: &mut R) -> Result<BigSize, DecodeError> {
 344                 let n: u8 = Readable::read(reader)?;
 345                 match n {
 346                         0xFF => {
 347                                 let x: u64 = Readable::read(reader)?;
 348                                 if x < 0x100000000 {
 349                                         Err(DecodeError::InvalidValue)
 350                                 } else {
 351                                         Ok(BigSize(x))
 352                                 }
 353                         }
 354                         0xFE => {
 355                                 let x: u32 = Readable::read(reader)?;
 356                                 if x < 0x10000 {
 357                                         Err(DecodeError::InvalidValue)
 358                                 } else {
 359                                         Ok(BigSize(x as u64))
 360                                 }
 361                         }
 362                         0xFD => {
 363                                 let x: u16 = Readable::read(reader)?;
 364                                 if x < 0xFD {
 365                                         Err(DecodeError::InvalidValue)
 366                                 } else {
 367                                         Ok(BigSize(x as u64))
 368                                 }
 369                         }
 370                         n => Ok(BigSize(n as u64))
 371                 }
 372         }
 373 }
 374
 375 /// In TLV we occasionally send fields which only consist of, or potentially end with, a
 376 /// variable-length integer which is simply truncated by skipping high zero bytes. This type
 377 /// encapsulates such integers implementing Readable/Writeable for them.
 378 #[cfg_attr(test, derive(PartialEq, Debug))]
 379 pub(crate) struct HighZeroBytesDroppedVarInt<T>(pub T);
 380
 381 macro_rules! impl_writeable_primitive {
 382         ($val_type:ty, $len: expr) => {
 383                 impl Writeable for $val_type {
 384                         #[inline]
 385                         fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
 386                                 writer.write_all(&self.to_be_bytes())
 387                         }
 388                 }
 389                 impl Writeable for HighZeroBytesDroppedVarInt<$val_type> {
 390                         #[inline]
 391                         fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
 392                                 // Skip any full leading 0 bytes when writing (in BE):
 393                                 writer.write_all(&self.0.to_be_bytes()[(self.0.leading_zeros()/8) as usize..$len])
 394                         }
 395                 }
 396                 impl Readable for $val_type {
 397                         #[inline]
 398                         fn read<R: Read>(reader: &mut R) -> Result<$val_type, DecodeError> {
 399                                 let mut buf = [0; $len];
 400                                 reader.read_exact(&mut buf)?;
 401                                 Ok(<$val_type>::from_be_bytes(buf))
 402                         }
 403                 }
 404                 impl Readable for HighZeroBytesDroppedVarInt<$val_type> {
 405                         #[inline]
 406                         fn read<R: Read>(reader: &mut R) -> Result<HighZeroBytesDroppedVarInt<$val_type>, DecodeError> {
 407                                 // We need to accept short reads (read_len == 0) as "EOF" and handle them as simply
 408                                 // the high bytes being dropped. To do so, we start reading into the middle of buf
 409                                 // and then convert the appropriate number of bytes with extra high bytes out of
 410                                 // buf.
 411                                 let mut buf = [0; $len*2];
 412                                 let mut read_len = reader.read(&mut buf[$len..])?;
 413                                 let mut total_read_len = read_len;
 414                                 while read_len != 0 && total_read_len != $len {
 415                                         read_len = reader.read(&mut buf[($len + total_read_len)..])?;
 416                                         total_read_len += read_len;
 417                                 }
 418                                 if total_read_len == 0 || buf[$len] != 0 {
 419                                         let first_byte = $len - ($len - total_read_len);
 420                                         let mut bytes = [0; $len];
 421                                         bytes.copy_from_slice(&buf[first_byte..first_byte + $len]);
 422                                         Ok(HighZeroBytesDroppedVarInt(<$val_type>::from_be_bytes(bytes)))
 423                                 } else {
 424                                         // If the encoding had extra zero bytes, return a failure even though we know
 425                                         // what they meant (as the TLV test vectors require this)
 426                                         Err(DecodeError::InvalidValue)
 427                                 }
 428                         }
 429                 }
 430         }
 431 }
 432
 433 impl_writeable_primitive!(u64, 8);
 434 impl_writeable_primitive!(u32, 4);
 435 impl_writeable_primitive!(u16, 2);
 436
 437 impl Writeable for u8 {
 438         #[inline]
 439         fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
 440                 writer.write_all(&[*self])
 441         }
 442 }
 443 impl Readable for u8 {
 444         #[inline]
 445         fn read<R: Read>(reader: &mut R) -> Result<u8, DecodeError> {
 446                 let mut buf = [0; 1];
 447                 reader.read_exact(&mut buf)?;
 448                 Ok(buf[0])
 449         }
 450 }
 451
 452 impl Writeable for bool {
 453         #[inline]
 454         fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
 455                 writer.write_all(&[if *self {1} else {0}])
 456         }
 457 }
 458 impl Readable for bool {
 459         #[inline]
 460         fn read<R: Read>(reader: &mut R) -> Result<bool, DecodeError> {
 461                 let mut buf = [0; 1];
 462                 reader.read_exact(&mut buf)?;
 463                 if buf[0] != 0 && buf[0] != 1 {
 464                         return Err(DecodeError::InvalidValue);
 465                 }
 466                 Ok(buf[0] == 1)
 467         }
 468 }
 469
 470 // u8 arrays
 471 macro_rules! impl_array {
 472         ( $size:expr ) => (
 473                 impl Writeable for [u8; $size]
 474                 {
 475                         #[inline]
 476                         fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 477                                 w.write_all(self)
 478                         }
 479                 }
 480
 481                 impl Readable for [u8; $size]
 482                 {
 483                         #[inline]
 484                         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 485                                 let mut buf = [0u8; $size];
 486                                 r.read_exact(&mut buf)?;
 487                                 Ok(buf)
 488                         }
 489                 }
 490         );
 491 }
 492
 493 //TODO: performance issue with [u8; size] with impl_array!()
 494 impl_array!(3); // for rgb
 495 impl_array!(4); // for IPv4
 496 impl_array!(10); // for OnionV2
 497 impl_array!(16); // for IPv6
 498 impl_array!(32); // for channel id & hmac
 499 impl_array!(PUBLIC_KEY_SIZE); // for PublicKey
 500 impl_array!(COMPACT_SIGNATURE_SIZE); // for Signature
 501 impl_array!(1300); // for OnionPacket.hop_data
 502
 503 // HashMap
 504 impl<K, V> Writeable for HashMap<K, V>
 505         where K: Writeable + Eq + Hash,
 506               V: Writeable
 507 {
 508         #[inline]
 509         fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 510         (self.len() as u16).write(w)?;
 511                 for (key, value) in self.iter() {
 512                         key.write(w)?;
 513                         value.write(w)?;
 514                 }
 515                 Ok(())
 516         }
 517 }
 518
 519 impl<K, V> Readable for HashMap<K, V>
 520         where K: Readable + Eq + Hash,
 521               V: Readable
 522 {
 523         #[inline]
 524         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 525                 let len: u16 = Readable::read(r)?;
 526                 let mut ret = HashMap::with_capacity(len as usize);
 527                 for _ in 0..len {
 528                         ret.insert(K::read(r)?, V::read(r)?);
 529                 }
 530                 Ok(ret)
 531         }
 532 }
 533
 534 // Vectors
 535 impl Writeable for Vec<u8> {
 536         #[inline]
 537         fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 538                 (self.len() as u16).write(w)?;
 539                 w.write_all(&self)
 540         }
 541 }
 542
 543 impl Readable for Vec<u8> {
 544         #[inline]
 545         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 546                 let len: u16 = Readable::read(r)?;
 547                 let mut ret = Vec::with_capacity(len as usize);
 548                 ret.resize(len as usize, 0);
 549                 r.read_exact(&mut ret)?;
 550                 Ok(ret)
 551         }
 552 }
 553 impl Writeable for Vec<Signature> {
 554         #[inline]
 555         fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 556                 (self.len() as u16).write(w)?;
 557                 for e in self.iter() {
 558                         e.write(w)?;
 559                 }
 560                 Ok(())
 561         }
 562 }
 563
 564 impl Readable for Vec<Signature> {
 565         #[inline]
 566         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 567                 let len: u16 = Readable::read(r)?;
 568                 let byte_size = (len as usize)
 569                                 .checked_mul(COMPACT_SIGNATURE_SIZE)
 570                                 .ok_or(DecodeError::BadLengthDescriptor)?;
 571                 if byte_size > MAX_BUF_SIZE {
 572                         return Err(DecodeError::BadLengthDescriptor);
 573                 }
 574                 let mut ret = Vec::with_capacity(len as usize);
 575                 for _ in 0..len { ret.push(Signature::read(r)?); }
 576                 Ok(ret)
 577         }
 578 }
 579
 580 impl Writeable for Script {
 581         fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 582                 (self.len() as u16).write(w)?;
 583                 w.write_all(self.as_bytes())
 584         }
 585 }
 586
 587 impl Readable for Script {
 588         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 589                 let len = <u16 as Readable>::read(r)? as usize;
 590                 let mut buf = vec![0; len];
 591                 r.read_exact(&mut buf)?;
 592                 Ok(Script::from(buf))
 593         }
 594 }
 595
 596 impl Writeable for PublicKey {
 597         fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 598                 self.serialize().write(w)
 599         }
 600         #[inline]
 601         fn serialized_length(&self) -> usize {
 602                 PUBLIC_KEY_SIZE
 603         }
 604 }
 605
 606 impl Readable for PublicKey {
 607         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 608                 let buf: [u8; PUBLIC_KEY_SIZE] = Readable::read(r)?;
 609                 match PublicKey::from_slice(&buf) {
 610                         Ok(key) => Ok(key),
 611                         Err(_) => return Err(DecodeError::InvalidValue),
 612                 }
 613         }
 614 }
 615
 616 impl Writeable for SecretKey {
 617         fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 618                 let mut ser = [0; 32];
 619                 ser.copy_from_slice(&self[..]);
 620                 ser.write(w)
 621         }
 622         #[inline]
 623         fn serialized_length(&self) -> usize {
 624                 32
 625         }
 626 }
 627
 628 impl Readable for SecretKey {
 629         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 630                 let buf: [u8; 32] = Readable::read(r)?;
 631                 match SecretKey::from_slice(&buf) {
 632                         Ok(key) => Ok(key),
 633                         Err(_) => return Err(DecodeError::InvalidValue),
 634                 }
 635         }
 636 }
 637
 638 impl Writeable for Sha256dHash {
 639         fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 640                 w.write_all(&self[..])
 641         }
 642 }
 643
 644 impl Readable for Sha256dHash {
 645         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 646                 use bitcoin::hashes::Hash;
 647
 648                 let buf: [u8; 32] = Readable::read(r)?;
 649                 Ok(Sha256dHash::from_slice(&buf[..]).unwrap())
 650         }
 651 }
 652
 653 impl Writeable for Signature {
 654         fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 655                 self.serialize_compact().write(w)
 656         }
 657         #[inline]
 658         fn serialized_length(&self) -> usize {
 659                 COMPACT_SIGNATURE_SIZE
 660         }
 661 }
 662
 663 impl Readable for Signature {
 664         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 665                 let buf: [u8; COMPACT_SIGNATURE_SIZE] = Readable::read(r)?;
 666                 match Signature::from_compact(&buf) {
 667                         Ok(sig) => Ok(sig),
 668                         Err(_) => return Err(DecodeError::InvalidValue),
 669                 }
 670         }
 671 }
 672
 673 impl Writeable for PaymentPreimage {
 674         fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 675                 self.0.write(w)
 676         }
 677 }
 678
 679 impl Readable for PaymentPreimage {
 680         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 681                 let buf: [u8; 32] = Readable::read(r)?;
 682                 Ok(PaymentPreimage(buf))
 683         }
 684 }
 685
 686 impl Writeable for PaymentHash {
 687         fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 688                 self.0.write(w)
 689         }
 690 }
 691
 692 impl Readable for PaymentHash {
 693         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 694                 let buf: [u8; 32] = Readable::read(r)?;
 695                 Ok(PaymentHash(buf))
 696         }
 697 }
 698
 699 impl Writeable for PaymentSecret {
 700         fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 701                 self.0.write(w)
 702         }
 703 }
 704
 705 impl Readable for PaymentSecret {
 706         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 707                 let buf: [u8; 32] = Readable::read(r)?;
 708                 Ok(PaymentSecret(buf))
 709         }
 710 }
 711
 712 impl<T: Writeable> Writeable for Option<T> {
 713         fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 714                 match *self {
 715                         None => 0u8.write(w)?,
 716                         Some(ref data) => {
 717                                 BigSize(data.serialized_length() as u64 + 1).write(w)?;
 718                                 data.write(w)?;
 719                         }
 720                 }
 721                 Ok(())
 722         }
 723 }
 724
 725 impl<T: Readable> Readable for Option<T>
 726 {
 727         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 728                 match BigSize::read(r)?.0 {
 729                         0 => Ok(None),
 730                         len => {
 731                                 let mut reader = FixedLengthReader::new(r, len - 1);
 732                                 Ok(Some(Readable::read(&mut reader)?))
 733                         }
 734                 }
 735         }
 736 }
 737
 738 impl Writeable for Txid {
 739         fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 740                 w.write_all(&self[..])
 741         }
 742 }
 743
 744 impl Readable for Txid {
 745         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 746                 use bitcoin::hashes::Hash;
 747
 748                 let buf: [u8; 32] = Readable::read(r)?;
 749                 Ok(Txid::from_slice(&buf[..]).unwrap())
 750         }
 751 }
 752
 753 impl Writeable for BlockHash {
 754         fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 755                 w.write_all(&self[..])
 756         }
 757 }
 758
 759 impl Readable for BlockHash {
 760         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 761                 use bitcoin::hashes::Hash;
 762
 763                 let buf: [u8; 32] = Readable::read(r)?;
 764                 Ok(BlockHash::from_slice(&buf[..]).unwrap())
 765         }
 766 }
 767
 768 impl Writeable for OutPoint {
 769         fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 770                 self.txid.write(w)?;
 771                 self.vout.write(w)?;
 772                 Ok(())
 773         }
 774 }
 775
 776 impl Readable for OutPoint {
 777         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 778                 let txid = Readable::read(r)?;
 779                 let vout = Readable::read(r)?;
 780                 Ok(OutPoint {
 781                         txid,
 782                         vout,
 783                 })
 784         }
 785 }
 786
 787 macro_rules! impl_consensus_ser {
 788         ($bitcoin_type: ty) => {
 789                 impl Writeable for $bitcoin_type {
 790                         fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
 791                                 match self.consensus_encode(WriterWriteAdaptor(writer)) {
 792                                         Ok(_) => Ok(()),
 793                                         Err(e) => Err(e),
 794                                 }
 795                         }
 796                 }
 797
 798                 impl Readable for $bitcoin_type {
 799                         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 800                                 match consensus::encode::Decodable::consensus_decode(r) {
 801                                         Ok(t) => Ok(t),
 802                                         Err(consensus::encode::Error::Io(ref e)) if e.kind() == ::std::io::ErrorKind::UnexpectedEof => Err(DecodeError::ShortRead),
 803                                         Err(consensus::encode::Error::Io(e)) => Err(DecodeError::Io(e.kind())),
 804                                         Err(_) => Err(DecodeError::InvalidValue),
 805                                 }
 806                         }
 807                 }
 808         }
 809 }
 810 impl_consensus_ser!(Transaction);
 811 impl_consensus_ser!(TxOut);
 812
 813 impl<T: Readable> Readable for Mutex<T> {
 814         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 815                 let t: T = Readable::read(r)?;
 816                 Ok(Mutex::new(t))
 817         }
 818 }
 819 impl<T: Writeable> Writeable for Mutex<T> {
 820         fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 821                 self.lock().unwrap().write(w)
 822         }
 823 }
 824
 825 impl<A: Readable, B: Readable> Readable for (A, B) {
 826         fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
 827                 let a: A = Readable::read(r)?;
 828                 let b: B = Readable::read(r)?;
 829                 Ok((a, b))
 830         }
 831 }
 832 impl<A: Writeable, B: Writeable> Writeable for (A, B) {
 833         fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
 834                 self.0.write(w)?;
 835                 self.1.write(w)
 836         }
 837 }