Merge pull request #523 from TheBlueMatt/2020-02-router-ser-fix

[rust-lightning] / lightning / src / ln / channelmanager.rs

diff --git a/lightning/src/ln/channelmanager.rs b/lightning/src/ln/channelmanager.rs
index 63e32c1a57b0640d1536427b51e074fc59b43c2d..5f7e903fd201c6da81c0eadf20dd61d6f98e2dd6 100644 (file)
--- a/lightning/src/ln/channelmanager.rs
+++ b/lightning/src/ln/channelmanager.rs
@@ -3062,8 +3062,8 @@ impl Writeable for PendingHTLCInfo {
        }
 }
 
-impl<R: ::std::io::Read> Readable<R> for PendingHTLCInfo {
-       fn read(reader: &mut R) -> Result<PendingHTLCInfo, DecodeError> {
+impl Readable for PendingHTLCInfo {
+       fn read<R: ::std::io::Read>(reader: &mut R) -> Result<PendingHTLCInfo, DecodeError> {
                Ok(PendingHTLCInfo {
                        onion_packet: Readable::read(reader)?,
                        incoming_shared_secret: Readable::read(reader)?,
@@ -3091,9 +3091,9 @@ impl Writeable for HTLCFailureMsg {
        }
 }
 
-impl<R: ::std::io::Read> Readable<R> for HTLCFailureMsg {
-       fn read(reader: &mut R) -> Result<HTLCFailureMsg, DecodeError> {
-               match <u8 as Readable<R>>::read(reader)? {
+impl Readable for HTLCFailureMsg {
+       fn read<R: ::std::io::Read>(reader: &mut R) -> Result<HTLCFailureMsg, DecodeError> {
+               match <u8 as Readable>::read(reader)? {
                        0 => Ok(HTLCFailureMsg::Relay(Readable::read(reader)?)),
                        1 => Ok(HTLCFailureMsg::Malformed(Readable::read(reader)?)),
                        _ => Err(DecodeError::InvalidValue),
@@ -3117,9 +3117,9 @@ impl Writeable for PendingHTLCStatus {
        }
 }
 
-impl<R: ::std::io::Read> Readable<R> for PendingHTLCStatus {
-       fn read(reader: &mut R) -> Result<PendingHTLCStatus, DecodeError> {
-               match <u8 as Readable<R>>::read(reader)? {
+impl Readable for PendingHTLCStatus {
+       fn read<R: ::std::io::Read>(reader: &mut R) -> Result<PendingHTLCStatus, DecodeError> {
+               match <u8 as Readable>::read(reader)? {
                        0 => Ok(PendingHTLCStatus::Forward(Readable::read(reader)?)),
                        1 => Ok(PendingHTLCStatus::Fail(Readable::read(reader)?)),
                        _ => Err(DecodeError::InvalidValue),
@@ -3151,9 +3151,9 @@ impl Writeable for HTLCSource {
        }
 }
 
-impl<R: ::std::io::Read> Readable<R> for HTLCSource {
-       fn read(reader: &mut R) -> Result<HTLCSource, DecodeError> {
-               match <u8 as Readable<R>>::read(reader)? {
+impl Readable for HTLCSource {
+       fn read<R: ::std::io::Read>(reader: &mut R) -> Result<HTLCSource, DecodeError> {
+               match <u8 as Readable>::read(reader)? {
                        0 => Ok(HTLCSource::PreviousHopData(Readable::read(reader)?)),
                        1 => Ok(HTLCSource::OutboundRoute {
                                route: Readable::read(reader)?,
@@ -3182,9 +3182,9 @@ impl Writeable for HTLCFailReason {
        }
 }
 
-impl<R: ::std::io::Read> Readable<R> for HTLCFailReason {
-       fn read(reader: &mut R) -> Result<HTLCFailReason, DecodeError> {
-               match <u8 as Readable<R>>::read(reader)? {
+impl Readable for HTLCFailReason {
+       fn read<R: ::std::io::Read>(reader: &mut R) -> Result<HTLCFailReason, DecodeError> {
+               match <u8 as Readable>::read(reader)? {
                        0 => Ok(HTLCFailReason::LightningError { err: Readable::read(reader)? }),
                        1 => Ok(HTLCFailReason::Reason {
                                failure_code: Readable::read(reader)?,
@@ -3214,9 +3214,9 @@ impl Writeable for HTLCForwardInfo {
        }
 }
 
-impl<R: ::std::io::Read> Readable<R> for HTLCForwardInfo {
-       fn read(reader: &mut R) -> Result<HTLCForwardInfo, DecodeError> {
-               match <u8 as Readable<R>>::read(reader)? {
+impl Readable for HTLCForwardInfo {
+       fn read<R: ::std::io::Read>(reader: &mut R) -> Result<HTLCForwardInfo, DecodeError> {
+               match <u8 as Readable>::read(reader)? {
                        0 => Ok(HTLCForwardInfo::AddHTLC {
                                prev_short_channel_id: Readable::read(reader)?,
                                prev_htlc_id: Readable::read(reader)?,
@@ -3353,14 +3353,29 @@ pub struct ChannelManagerReadArgs<'a, ChanSigner: 'a + ChannelKeys, M: Deref, T:
        pub channel_monitors: &'a mut HashMap<OutPoint, &'a mut ChannelMonitor<ChanSigner>>,
 }
 
-impl<'a, R : ::std::io::Read, ChanSigner: ChannelKeys + Readable<R>, M: Deref, T: Deref, K: Deref, F: Deref>
-       ReadableArgs<R, ChannelManagerReadArgs<'a, ChanSigner, M, T, K, F>> for (Sha256dHash, ChannelManager<ChanSigner, M, T, K, F>)
+// Implement ReadableArgs for an Arc'd ChannelManager to make it a bit easier to work with the
+// SipmleArcChannelManager type:
+impl<'a, ChanSigner: ChannelKeys + Readable, M: Deref, T: Deref, K: Deref, F: Deref>
+       ReadableArgs<ChannelManagerReadArgs<'a, ChanSigner, M, T, K, F>> for (Sha256dHash, Arc<ChannelManager<ChanSigner, M, T, K, F>>)
        where M::Target: ManyChannelMonitor<ChanSigner>,
         T::Target: BroadcasterInterface,
         K::Target: KeysInterface<ChanKeySigner = ChanSigner>,
         F::Target: FeeEstimator,
 {
-       fn read(reader: &mut R, args: ChannelManagerReadArgs<'a, ChanSigner, M, T, K, F>) -> Result<Self, DecodeError> {
+       fn read<R: ::std::io::Read>(reader: &mut R, args: ChannelManagerReadArgs<'a, ChanSigner, M, T, K, F>) -> Result<Self, DecodeError> {
+               let (blockhash, chan_manager) = <(Sha256dHash, ChannelManager<ChanSigner, M, T, K, F>)>::read(reader, args)?;
+               Ok((blockhash, Arc::new(chan_manager)))
+       }
+}
+
+impl<'a, ChanSigner: ChannelKeys + Readable, M: Deref, T: Deref, K: Deref, F: Deref>
+       ReadableArgs<ChannelManagerReadArgs<'a, ChanSigner, M, T, K, F>> for (Sha256dHash, ChannelManager<ChanSigner, M, T, K, F>)
+       where M::Target: ManyChannelMonitor<ChanSigner>,
+        T::Target: BroadcasterInterface,
+        K::Target: KeysInterface<ChanKeySigner = ChanSigner>,
+        F::Target: FeeEstimator,
+{
+       fn read<R: ::std::io::Read>(reader: &mut R, args: ChannelManagerReadArgs<'a, ChanSigner, M, T, K, F>) -> Result<Self, DecodeError> {
                let _ver: u8 = Readable::read(reader)?;
                let min_ver: u8 = Readable::read(reader)?;
                if min_ver > SERIALIZATION_VERSION {