{
use lightning::util::ser::{Writeable, Readable};
let mut r = ::std::io::Cursor::new($data);
- if let Ok(msg) = <$MsgType as Readable<::std::io::Cursor<&[u8]>>>::read(&mut r) {
+ if let Ok(msg) = <$MsgType as Readable>::read(&mut r) {
let p = r.position() as usize;
let mut w = VecWriter(Vec::new());
msg.write(&mut w).unwrap();
{
use lightning::util::ser::{Writeable, Readable};
let mut r = ::std::io::Cursor::new($data);
- if let Ok(msg) = <$MsgType as Readable<::std::io::Cursor<&[u8]>>>::read(&mut r) {
+ if let Ok(msg) = <$MsgType as Readable>::read(&mut r) {
let mut w = VecWriter(Vec::new());
msg.write(&mut w).unwrap();
- let msg = <$MsgType as Readable<::std::io::Cursor<&[u8]>>>::read(&mut ::std::io::Cursor::new(&w.0)).unwrap();
+ let msg = <$MsgType as Readable>::read(&mut ::std::io::Cursor::new(&w.0)).unwrap();
let mut w_two = VecWriter(Vec::new());
msg.write(&mut w_two).unwrap();
assert_eq!(&w.0[..], &w_two.0[..]);
{
use lightning::util::ser::{Writeable, Readable};
let mut r = ::std::io::Cursor::new($data);
- if let Ok(msg) = <$MsgType as Readable<::std::io::Cursor<&[u8]>>>::read(&mut r) {
+ if let Ok(msg) = <$MsgType as Readable>::read(&mut r) {
let mut w = VecWriter(Vec::new());
msg.write(&mut w).unwrap();
assert_eq!(&r.into_inner()[..], &w.0[..]);
{
use lightning::util::ser::{Writeable, Readable};
let mut r = ::std::io::Cursor::new($data);
- if let Ok(msg) = <$MsgType as Readable<::std::io::Cursor<&[u8]>>>::read(&mut r) {
+ if let Ok(msg) = <$MsgType as Readable>::read(&mut r) {
let mut w = VecWriter(Vec::new());
msg.write(&mut w).unwrap();
let p = w.0.len() as usize;
}
}
-impl<R: ::std::io::Read> Readable<R> for SpendableOutputDescriptor {
- fn read(reader: &mut R) -> Result<Self, DecodeError> {
+impl Readable for SpendableOutputDescriptor {
+ fn read<R: ::std::io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
match Readable::read(reader)? {
0u8 => Ok(SpendableOutputDescriptor::StaticOutput {
outpoint: Readable::read(reader)?,
}
}
-impl<R: ::std::io::Read> Readable<R> for InMemoryChannelKeys {
- fn read(reader: &mut R) -> Result<Self, DecodeError> {
+impl Readable for InMemoryChannelKeys {
+ fn read<R: ::std::io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
let funding_key = Readable::read(reader)?;
let revocation_base_key = Readable::read(reader)?;
let payment_base_key = Readable::read(reader)?;
Ok(())
}
}
-impl<R: ::std::io::Read> Readable<R> for CounterpartyCommitmentSecrets {
- fn read(reader: &mut R) -> Result<Self, DecodeError> {
+impl Readable for CounterpartyCommitmentSecrets {
+ fn read<R: ::std::io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
let mut old_secrets = [([0; 32], 1 << 48); 49];
for &mut (ref mut secret, ref mut idx) in old_secrets.iter_mut() {
*secret = Readable::read(reader)?;
Ok(())
}
}
-impl<R: ::std::io::Read> Readable<R> for LocalCommitmentTransaction {
- fn read(reader: &mut R) -> Result<Self, DecodeError> {
+impl Readable for LocalCommitmentTransaction {
+ fn read<R: ::std::io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
let tx = match Transaction::consensus_decode(reader.by_ref()) {
Ok(tx) => tx,
Err(e) => match e {
}
}
-impl<R: ::std::io::Read> Readable<R> for InboundHTLCRemovalReason {
- fn read(reader: &mut R) -> Result<Self, DecodeError> {
- Ok(match <u8 as Readable<R>>::read(reader)? {
+impl Readable for InboundHTLCRemovalReason {
+ fn read<R: ::std::io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
+ Ok(match <u8 as Readable>::read(reader)? {
0 => InboundHTLCRemovalReason::FailRelay(Readable::read(reader)?),
1 => InboundHTLCRemovalReason::FailMalformed((Readable::read(reader)?, Readable::read(reader)?)),
2 => InboundHTLCRemovalReason::Fulfill(Readable::read(reader)?),
}
}
- macro_rules! write_option {
- ($thing: expr) => {
- match &$thing {
- &None => 0u8.write(writer)?,
- &Some(ref v) => {
- 1u8.write(writer)?;
- v.write(writer)?;
- },
- }
- }
- }
-
(self.pending_outbound_htlcs.len() as u64).write(writer)?;
for htlc in self.pending_outbound_htlcs.iter() {
htlc.htlc_id.write(writer)?;
},
&OutboundHTLCState::RemoteRemoved(ref fail_reason) => {
2u8.write(writer)?;
- write_option!(*fail_reason);
+ fail_reason.write(writer)?;
},
&OutboundHTLCState::AwaitingRemoteRevokeToRemove(ref fail_reason) => {
3u8.write(writer)?;
- write_option!(*fail_reason);
+ fail_reason.write(writer)?;
},
&OutboundHTLCState::AwaitingRemovedRemoteRevoke(ref fail_reason) => {
4u8.write(writer)?;
- write_option!(*fail_reason);
+ fail_reason.write(writer)?;
},
}
}
fail_reason.write(writer)?;
}
- write_option!(self.pending_update_fee);
- write_option!(self.holding_cell_update_fee);
+ self.pending_update_fee.write(writer)?;
+ self.holding_cell_update_fee.write(writer)?;
self.next_local_htlc_id.write(writer)?;
(self.next_remote_htlc_id - dropped_inbound_htlcs).write(writer)?;
None => 0u8.write(writer)?,
}
- write_option!(self.funding_txo);
- write_option!(self.funding_tx_confirmed_in);
- write_option!(self.short_channel_id);
+ self.funding_txo.write(writer)?;
+ self.funding_tx_confirmed_in.write(writer)?;
+ self.short_channel_id.write(writer)?;
self.last_block_connected.write(writer)?;
self.funding_tx_confirmations.write(writer)?;
self.their_max_accepted_htlcs.write(writer)?;
self.minimum_depth.write(writer)?;
- write_option!(self.their_pubkeys);
- write_option!(self.their_cur_commitment_point);
+ self.their_pubkeys.write(writer)?;
+ self.their_cur_commitment_point.write(writer)?;
- write_option!(self.their_prev_commitment_point);
+ self.their_prev_commitment_point.write(writer)?;
self.their_node_id.write(writer)?;
- write_option!(self.their_shutdown_scriptpubkey);
+ self.their_shutdown_scriptpubkey.write(writer)?;
self.commitment_secrets.write(writer)?;
}
}
-impl<R : ::std::io::Read, ChanSigner: ChannelKeys + Readable<R>> ReadableArgs<R, Arc<Logger>> for Channel<ChanSigner> {
- fn read(reader: &mut R, logger: Arc<Logger>) -> Result<Self, DecodeError> {
+impl<ChanSigner: ChannelKeys + Readable> ReadableArgs<Arc<Logger>> for Channel<ChanSigner> {
+ fn read<R : ::std::io::Read>(reader: &mut R, logger: Arc<Logger>) -> Result<Self, DecodeError> {
let _ver: u8 = Readable::read(reader)?;
let min_ver: u8 = Readable::read(reader)?;
if min_ver > SERIALIZATION_VERSION {
amount_msat: Readable::read(reader)?,
cltv_expiry: Readable::read(reader)?,
payment_hash: Readable::read(reader)?,
- state: match <u8 as Readable<R>>::read(reader)? {
+ state: match <u8 as Readable>::read(reader)? {
1 => InboundHTLCState::AwaitingRemoteRevokeToAnnounce(Readable::read(reader)?),
2 => InboundHTLCState::AwaitingAnnouncedRemoteRevoke(Readable::read(reader)?),
3 => InboundHTLCState::Committed,
cltv_expiry: Readable::read(reader)?,
payment_hash: Readable::read(reader)?,
source: Readable::read(reader)?,
- state: match <u8 as Readable<R>>::read(reader)? {
+ state: match <u8 as Readable>::read(reader)? {
0 => OutboundHTLCState::LocalAnnounced(Box::new(Readable::read(reader)?)),
1 => OutboundHTLCState::Committed,
2 => OutboundHTLCState::RemoteRemoved(Readable::read(reader)?),
let holding_cell_htlc_update_count: u64 = Readable::read(reader)?;
let mut holding_cell_htlc_updates = Vec::with_capacity(cmp::min(holding_cell_htlc_update_count as usize, OUR_MAX_HTLCS as usize*2));
for _ in 0..holding_cell_htlc_update_count {
- holding_cell_htlc_updates.push(match <u8 as Readable<R>>::read(reader)? {
+ holding_cell_htlc_updates.push(match <u8 as Readable>::read(reader)? {
0 => HTLCUpdateAwaitingACK::AddHTLC {
amount_msat: Readable::read(reader)?,
cltv_expiry: Readable::read(reader)?,
});
}
- let resend_order = match <u8 as Readable<R>>::read(reader)? {
+ let resend_order = match <u8 as Readable>::read(reader)? {
0 => RAACommitmentOrder::CommitmentFirst,
1 => RAACommitmentOrder::RevokeAndACKFirst,
_ => return Err(DecodeError::InvalidValue),
let channel_update_count = Readable::read(reader)?;
let feerate_per_kw = Readable::read(reader)?;
- let last_sent_closing_fee = match <u8 as Readable<R>>::read(reader)? {
+ let last_sent_closing_fee = match <u8 as Readable>::read(reader)? {
0 => None,
1 => Some((Readable::read(reader)?, Readable::read(reader)?, Readable::read(reader)?)),
_ => return Err(DecodeError::InvalidValue),
}
}
-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)?,
}
}
-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),
}
}
-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),
}
}
-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)?,
}
}
-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)?,
}
}
-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)?,
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 {
Ok(())
}
}
-impl<R: ::std::io::Read> Readable<R> for ChannelMonitorUpdate {
- fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for ChannelMonitorUpdate {
+ fn read<R: ::std::io::Read>(r: &mut R) -> Result<Self, DecodeError> {
let update_id: u64 = Readable::read(r)?;
let len: u64 = Readable::read(r)?;
let mut updates = Vec::with_capacity(cmp::min(len as usize, MAX_ALLOC_SIZE / ::std::mem::size_of::<ChannelMonitorUpdateStep>()));
script.write(writer)?;
pubkey.write(writer)?;
writer.write_all(&key[..])?;
- if *is_htlc {
- writer.write_all(&[0; 1])?;
- } else {
- writer.write_all(&[1; 1])?;
- }
+ is_htlc.write(writer)?;
writer.write_all(&byte_utils::be64_to_array(*amount))?;
},
&InputMaterial::RemoteHTLC { ref script, ref key, ref preimage, ref amount, ref locktime } => {
}
}
-impl<R: ::std::io::Read> Readable<R> for InputMaterial {
- fn read(reader: &mut R) -> Result<Self, DecodeError> {
- let input_material = match <u8 as Readable<R>>::read(reader)? {
+impl Readable for InputMaterial {
+ fn read<R: ::std::io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
+ let input_material = match <u8 as Readable>::read(reader)? {
0 => {
let script = Readable::read(reader)?;
let pubkey = Readable::read(reader)?;
let key = Readable::read(reader)?;
- let is_htlc = match <u8 as Readable<R>>::read(reader)? {
- 0 => true,
- 1 => false,
- _ => return Err(DecodeError::InvalidValue),
- };
+ let is_htlc = Readable::read(reader)?;
let amount = Readable::read(reader)?;
InputMaterial::Revoked {
script,
}
}
-impl<R: ::std::io::Read> Readable<R> for ClaimTxBumpMaterial {
- fn read(reader: &mut R) -> Result<Self, DecodeError> {
+impl Readable for ClaimTxBumpMaterial {
+ fn read<R: ::std::io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
let height_timer = Readable::read(reader)?;
let feerate_previous = Readable::read(reader)?;
let soonest_timelock = Readable::read(reader)?;
(htlc_outputs.len() as u64).write(w)?;
for &(ref output, ref source) in htlc_outputs.iter() {
output.write(w)?;
- match source {
- &None => 0u8.write(w)?,
- &Some(ref s) => {
- 1u8.write(w)?;
- s.write(w)?;
- },
- }
+ source.as_ref().map(|b| b.as_ref()).write(w)?;
}
},
&ChannelMonitorUpdateStep::PaymentPreimage { ref payment_preimage } => {
Ok(())
}
}
-impl<R: ::std::io::Read> Readable<R> for ChannelMonitorUpdateStep {
- fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for ChannelMonitorUpdateStep {
+ fn read<R: ::std::io::Read>(r: &mut R) -> Result<Self, DecodeError> {
match Readable::read(r)? {
0u8 => {
Ok(ChannelMonitorUpdateStep::LatestLocalCommitmentTXInfo {
let len: u64 = Readable::read(r)?;
let mut res = Vec::new();
for _ in 0..len {
- res.push((Readable::read(r)?, <Option<HTLCSource> as Readable<R>>::read(r)?.map(|o| Box::new(o))));
+ res.push((Readable::read(r)?, <Option<HTLCSource> as Readable>::read(r)?.map(|o| Box::new(o))));
}
res
},
// Set in initial Channel-object creation, so should always be set by now:
U48(self.commitment_transaction_number_obscure_factor).write(writer)?;
- macro_rules! write_option {
- ($thing: expr) => {
- match $thing {
- &Some(ref t) => {
- 1u8.write(writer)?;
- t.write(writer)?;
- },
- &None => 0u8.write(writer)?,
- }
- }
- }
-
match self.key_storage {
Storage::Local { ref keys, ref funding_key, ref revocation_base_key, ref htlc_base_key, ref delayed_payment_base_key, ref payment_base_key, ref shutdown_pubkey, ref funding_info, ref current_remote_commitment_txid, ref prev_remote_commitment_txid } => {
writer.write_all(&[0; 1])?;
writer.write_all(&byte_utils::be64_to_array(htlc_infos.len() as u64))?;
for &(ref htlc_output, ref htlc_source) in htlc_infos.iter() {
serialize_htlc_in_commitment!(htlc_output);
- write_option!(htlc_source);
+ htlc_source.as_ref().map(|b| b.as_ref()).write(writer)?;
}
}
} else {
0u8.write(writer)?;
}
- write_option!(htlc_source);
+ htlc_source.write(writer)?;
}
}
}
const MAX_ALLOC_SIZE: usize = 64*1024;
-impl<R: ::std::io::Read, ChanSigner: ChannelKeys + Readable<R>> ReadableArgs<R, Arc<Logger>> for (Sha256dHash, ChannelMonitor<ChanSigner>) {
- fn read(reader: &mut R, logger: Arc<Logger>) -> Result<Self, DecodeError> {
+impl<ChanSigner: ChannelKeys + Readable> ReadableArgs<Arc<Logger>> for (Sha256dHash, ChannelMonitor<ChanSigner>) {
+ fn read<R: ::std::io::Read>(reader: &mut R, logger: Arc<Logger>) -> Result<Self, DecodeError> {
let secp_ctx = Secp256k1::new();
macro_rules! unwrap_obj {
($key: expr) => {
}
let latest_update_id: u64 = Readable::read(reader)?;
- let commitment_transaction_number_obscure_factor = <U48 as Readable<R>>::read(reader)?.0;
+ let commitment_transaction_number_obscure_factor = <U48 as Readable>::read(reader)?.0;
- let key_storage = match <u8 as Readable<R>>::read(reader)? {
+ let key_storage = match <u8 as Readable>::read(reader)? {
0 => {
let keys = Readable::read(reader)?;
let funding_key = Readable::read(reader)?;
let channel_value_satoshis = Some(Readable::read(reader)?);
let their_cur_revocation_points = {
- let first_idx = <U48 as Readable<R>>::read(reader)?.0;
+ let first_idx = <U48 as Readable>::read(reader)?.0;
if first_idx == 0 {
None
} else {
let htlcs_count: u64 = Readable::read(reader)?;
let mut htlcs = Vec::with_capacity(cmp::min(htlcs_count as usize, MAX_ALLOC_SIZE / 32));
for _ in 0..htlcs_count {
- htlcs.push((read_htlc_in_commitment!(), <Option<HTLCSource> as Readable<R>>::read(reader)?.map(|o: HTLCSource| Box::new(o))));
+ htlcs.push((read_htlc_in_commitment!(), <Option<HTLCSource> as Readable>::read(reader)?.map(|o: HTLCSource| Box::new(o))));
}
if let Some(_) = remote_claimable_outpoints.insert(txid, htlcs) {
return Err(DecodeError::InvalidValue);
let mut remote_commitment_txn_on_chain = HashMap::with_capacity(cmp::min(remote_commitment_txn_on_chain_len as usize, MAX_ALLOC_SIZE / 32));
for _ in 0..remote_commitment_txn_on_chain_len {
let txid: Sha256dHash = Readable::read(reader)?;
- let commitment_number = <U48 as Readable<R>>::read(reader)?.0;
- let outputs_count = <u64 as Readable<R>>::read(reader)?;
+ let commitment_number = <U48 as Readable>::read(reader)?.0;
+ let outputs_count = <u64 as Readable>::read(reader)?;
let mut outputs = Vec::with_capacity(cmp::min(outputs_count as usize, MAX_ALLOC_SIZE / 8));
for _ in 0..outputs_count {
outputs.push(Readable::read(reader)?);
let mut remote_hash_commitment_number = HashMap::with_capacity(cmp::min(remote_hash_commitment_number_len as usize, MAX_ALLOC_SIZE / 32));
for _ in 0..remote_hash_commitment_number_len {
let payment_hash: PaymentHash = Readable::read(reader)?;
- let commitment_number = <U48 as Readable<R>>::read(reader)?.0;
+ let commitment_number = <U48 as Readable>::read(reader)?.0;
if let Some(_) = remote_hash_commitment_number.insert(payment_hash, commitment_number) {
return Err(DecodeError::InvalidValue);
}
macro_rules! read_local_tx {
() => {
{
- let tx = <LocalCommitmentTransaction as Readable<R>>::read(reader)?;
+ let tx = <LocalCommitmentTransaction as Readable>::read(reader)?;
let revocation_key = Readable::read(reader)?;
let a_htlc_key = Readable::read(reader)?;
let b_htlc_key = Readable::read(reader)?;
let mut htlcs = Vec::with_capacity(cmp::min(htlcs_len as usize, MAX_ALLOC_SIZE / 128));
for _ in 0..htlcs_len {
let htlc = read_htlc_in_commitment!();
- let sigs = match <u8 as Readable<R>>::read(reader)? {
+ let sigs = match <u8 as Readable>::read(reader)? {
0 => None,
1 => Some(Readable::read(reader)?),
_ => return Err(DecodeError::InvalidValue),
}
}
- let prev_local_signed_commitment_tx = match <u8 as Readable<R>>::read(reader)? {
+ let prev_local_signed_commitment_tx = match <u8 as Readable>::read(reader)? {
0 => None,
1 => {
Some(read_local_tx!())
_ => return Err(DecodeError::InvalidValue),
};
- let current_local_signed_commitment_tx = match <u8 as Readable<R>>::read(reader)? {
+ let current_local_signed_commitment_tx = match <u8 as Readable>::read(reader)? {
0 => None,
1 => {
Some(read_local_tx!())
_ => return Err(DecodeError::InvalidValue),
};
- let current_remote_commitment_number = <U48 as Readable<R>>::read(reader)?.0;
+ let current_remote_commitment_number = <U48 as Readable>::read(reader)?.0;
let payment_preimages_len: u64 = Readable::read(reader)?;
let mut payment_preimages = HashMap::with_capacity(cmp::min(payment_preimages_len as usize, MAX_ALLOC_SIZE / 32));
let last_block_hash: Sha256dHash = Readable::read(reader)?;
let destination_script = Readable::read(reader)?;
- let to_remote_rescue = match <u8 as Readable<R>>::read(reader)? {
+ let to_remote_rescue = match <u8 as Readable>::read(reader)? {
0 => None,
1 => {
let to_remote_script = Readable::read(reader)?;
let events_len: u64 = Readable::read(reader)?;
let mut events = Vec::with_capacity(cmp::min(events_len as usize, MAX_ALLOC_SIZE / 128));
for _ in 0..events_len {
- let ev = match <u8 as Readable<R>>::read(reader)? {
+ let ev = match <u8 as Readable>::read(reader)? {
0 => {
let claim_request = Readable::read(reader)?;
OnchainEvent::Claim {
}
}
-impl<R: ::std::io::Read, T: sealed::Context> Readable<R> for Features<T> {
- fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl<T: sealed::Context> Readable for Features<T> {
+ fn read<R: ::std::io::Read>(r: &mut R) -> Result<Self, DecodeError> {
let mut flags: Vec<u8> = Readable::read(r)?;
flags.reverse(); // Swap to little-endian
Ok(Self {
use chain::keysinterface::KeysInterface;
use ln::channelmanager::{ChannelManager, ChannelManagerReadArgs, RAACommitmentOrder, PaymentPreimage, PaymentHash};
use ln::channelmonitor::{ChannelMonitor, ManyChannelMonitor};
-use ln::router::{Route, Router};
+use ln::router::{Route, Router, RouterReadArgs};
use ln::features::InitFeatures;
use ln::msgs;
use ln::msgs::{ChannelMessageHandler,RoutingMessageHandler};
assert!(self.node.get_and_clear_pending_events().is_empty());
assert!(self.chan_monitor.added_monitors.lock().unwrap().is_empty());
+ // Check that if we serialize the Router, we can deserialize it again.
+ {
+ let mut w = test_utils::TestVecWriter(Vec::new());
+ self.router.write(&mut w).unwrap();
+ let deserialized_router = Router::read(&mut ::std::io::Cursor::new(&w.0), RouterReadArgs {
+ chain_monitor: Arc::clone(&self.chain_monitor) as Arc<chaininterface::ChainWatchInterface>,
+ logger: Arc::clone(&self.logger) as Arc<Logger>
+ }).unwrap();
+ let mut chan_progress = 0;
+ loop {
+ let orig_announcements = self.router.get_next_channel_announcements(chan_progress, 255);
+ let deserialized_announcements = deserialized_router.get_next_channel_announcements(chan_progress, 255);
+ assert!(orig_announcements == deserialized_announcements);
+ chan_progress = match orig_announcements.last() {
+ Some(announcement) => announcement.0.contents.short_channel_id + 1,
+ None => break,
+ };
+ }
+ let mut node_progress = None;
+ loop {
+ let orig_announcements = self.router.get_next_node_announcements(node_progress.as_ref(), 255);
+ let deserialized_announcements = deserialized_router.get_next_node_announcements(node_progress.as_ref(), 255);
+ assert!(orig_announcements == deserialized_announcements);
+ node_progress = match orig_announcements.last() {
+ Some(announcement) => Some(announcement.contents.node_id),
+ None => break,
+ };
+ }
+ }
+
// Check that if we serialize and then deserialize all our channel monitors we get the
// same set of outputs to watch for on chain as we have now. Note that if we write
// tests that fully close channels and remove the monitors at some point this may break.
}
}
-impl<R: ::std::io::Read> Readable<R> for Result<NetAddress, u8> {
- fn read(reader: &mut R) -> Result<Result<NetAddress, u8>, DecodeError> {
- let byte = <u8 as Readable<R>>::read(reader)?;
+impl Readable for Result<NetAddress, u8> {
+ fn read<R: Read>(reader: &mut R) -> Result<Result<NetAddress, u8>, DecodeError> {
+ let byte = <u8 as Readable>::read(reader)?;
match byte {
1 => {
Ok(Ok(NetAddress::IPv4 {
}
}
-impl<R: Read> Readable<R> for OptionalField<Script> {
- fn read(r: &mut R) -> Result<Self, DecodeError> {
- match <u16 as Readable<R>>::read(r) {
+impl Readable for OptionalField<Script> {
+ fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+ match <u16 as Readable>::read(r) {
Ok(len) => {
let mut buf = vec![0; len as usize];
r.read_exact(&mut buf)?;
}
}
-impl<R: Read> Readable<R> for ChannelReestablish{
- fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for ChannelReestablish{
+ fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
Ok(Self {
channel_id: Readable::read(r)?,
next_local_commitment_number: Readable::read(r)?,
next_remote_commitment_number: Readable::read(r)?,
data_loss_protect: {
- match <[u8; 32] as Readable<R>>::read(r) {
+ match <[u8; 32] as Readable>::read(r) {
Ok(your_last_per_commitment_secret) =>
OptionalField::Present(DataLossProtect {
your_last_per_commitment_secret,
}
}
-impl<R: Read> Readable<R> for Init {
- fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for Init {
+ fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
let global_features: InitFeatures = Readable::read(r)?;
let features: InitFeatures = Readable::read(r)?;
Ok(Init {
}
}
-impl<R: Read> Readable<R> for OnionPacket {
- fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for OnionPacket {
+ fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
Ok(OnionPacket {
version: Readable::read(r)?,
public_key: {
}
}
-impl<R: Read> Readable<R> for OnionHopData {
- fn read(mut r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for OnionHopData {
+ fn read<R: Read>(mut r: &mut R) -> Result<Self, DecodeError> {
use bitcoin::consensus::encode::{Decodable, Error, VarInt};
let v: VarInt = Decodable::consensus_decode(&mut r)
.map_err(|e| match e {
}
}
-impl<R: Read> Readable<R> for Ping {
- fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for Ping {
+ fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
Ok(Ping {
ponglen: Readable::read(r)?,
byteslen: {
}
}
-impl<R: Read> Readable<R> for Pong {
- fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for Pong {
+ fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
Ok(Pong {
byteslen: {
let byteslen = Readable::read(r)?;
}
}
-impl<R: Read> Readable<R> for UnsignedChannelAnnouncement {
- fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for UnsignedChannelAnnouncement {
+ fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
Ok(Self {
features: Readable::read(r)?,
chain_hash: Readable::read(r)?,
}
}
-impl<R: Read> Readable<R> for UnsignedChannelUpdate {
- fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for UnsignedChannelUpdate {
+ fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
Ok(Self {
chain_hash: Readable::read(r)?,
short_channel_id: Readable::read(r)?,
}
}
-impl<R: Read> Readable<R> for ErrorMessage {
- fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for ErrorMessage {
+ fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
Ok(Self {
channel_id: Readable::read(r)?,
data: {
- let mut sz: usize = <u16 as Readable<R>>::read(r)? as usize;
+ let mut sz: usize = <u16 as Readable>::read(r)? as usize;
let mut data = vec![];
let data_len = r.read_to_end(&mut data)?;
sz = cmp::min(data_len, sz);
}
}
-impl<R: Read> Readable<R> for UnsignedNodeAnnouncement {
- fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for UnsignedNodeAnnouncement {
+ fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
let features: NodeFeatures = Readable::read(r)?;
let timestamp: u32 = Readable::read(r)?;
let node_id: PublicKey = Readable::read(r)?;
}
}
-impl<R: ::std::io::Read> Readable<R> for Route {
- fn read(reader: &mut R) -> Result<Route, DecodeError> {
+impl Readable for Route {
+ fn read<R: ::std::io::Read>(reader: &mut R) -> Result<Route, DecodeError> {
let hops_count: u8 = Readable::read(reader)?;
let mut hops = Vec::with_capacity(hops_count as usize);
for _ in 0..hops_count {
const MAX_ALLOC_SIZE: u64 = 64*1024;
-impl<R: ::std::io::Read> Readable<R> for NodeInfo {
- fn read(reader: &mut R) -> Result<NodeInfo, DecodeError> {
+impl Readable for NodeInfo {
+ fn read<R: ::std::io::Read>(reader: &mut R) -> Result<NodeInfo, DecodeError> {
let channels_count: u64 = Readable::read(reader)?;
let mut channels = Vec::with_capacity(cmp::min(channels_count, MAX_ALLOC_SIZE / 8) as usize);
for _ in 0..channels_count {
}
}
-impl<R: ::std::io::Read> Readable<R> for NetworkMap {
- fn read(reader: &mut R) -> Result<NetworkMap, DecodeError> {
+impl Readable for NetworkMap {
+ fn read<R: ::std::io::Read>(reader: &mut R) -> Result<NetworkMap, DecodeError> {
let channels_count: u64 = Readable::read(reader)?;
let mut channels = BTreeMap::new();
for _ in 0..channels_count {
pub logger: Arc<Logger>,
}
-impl<R: ::std::io::Read> ReadableArgs<R, RouterReadArgs> for Router {
- fn read(reader: &mut R, args: RouterReadArgs) -> Result<Router, DecodeError> {
+impl ReadableArgs<RouterReadArgs> for Router {
+ fn read<R: ::std::io::Read>(reader: &mut R, args: RouterReadArgs) -> Result<Router, DecodeError> {
let _ver: u8 = Readable::read(reader)?;
let min_ver: u8 = Readable::read(reader)?;
if min_ver > SERIALIZATION_VERSION {
///
/// Returns an error if the message payload code not be decoded as the specified type.
pub fn read<R: ::std::io::Read>(buffer: &mut R) -> Result<Message, msgs::DecodeError> {
- let message_type = <u16 as Readable<R>>::read(buffer)?;
+ let message_type = <u16 as Readable>::read(buffer)?;
match message_type {
msgs::Init::TYPE => {
Ok(Message::Init(Readable::read(buffer)?))
}
}
-impl<R: ::std::io::Read> Readable<R> for EnforcingChannelKeys {
- fn read(reader: &mut R) -> Result<Self, DecodeError> {
+impl Readable for EnforcingChannelKeys {
+ fn read<R: ::std::io::Read>(reader: &mut R) -> Result<Self, DecodeError> {
let inner = Readable::read(reader)?;
let obscure_and_last = Readable::read(reader)?;
Ok(EnforcingChannelKeys {
Ok(())
}
}
-impl<R: ::std::io::Read> MaybeReadable<R> for Event {
- fn read(reader: &mut R) -> Result<Option<Self>, msgs::DecodeError> {
+impl MaybeReadable for Event {
+ fn read<R: ::std::io::Read>(reader: &mut R) -> Result<Option<Self>, msgs::DecodeError> {
match Readable::read(reader)? {
0u8 => Ok(None),
1u8 => Ok(Some(Event::FundingBroadcastSafe {
}
}
+impl<'a, T: Writeable> Writeable for &'a T {
+ fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> { (*self).write(writer) }
+}
+
/// A trait that various rust-lightning types implement allowing them to be read in from a Read
-pub trait Readable<R>
- where Self: Sized,
- R: Read
+pub trait Readable
+ where Self: Sized
{
/// Reads a Self in from the given Read
- fn read(reader: &mut R) -> Result<Self, DecodeError>;
+ fn read<R: Read>(reader: &mut R) -> Result<Self, DecodeError>;
}
/// A trait that various higher-level rust-lightning types implement allowing them to be read in
/// from a Read given some additional set of arguments which is required to deserialize.
-pub trait ReadableArgs<R, P>
- where Self: Sized,
- R: Read
+pub trait ReadableArgs<P>
+ where Self: Sized
{
/// Reads a Self in from the given Read
- fn read(reader: &mut R, params: P) -> Result<Self, DecodeError>;
+ fn read<R: Read>(reader: &mut R, params: P) -> Result<Self, DecodeError>;
}
/// A trait that various rust-lightning types implement allowing them to (maybe) be read in from a Read
-pub trait MaybeReadable<R>
- where Self: Sized,
- R: Read
+pub trait MaybeReadable
+ where Self: Sized
{
/// Reads a Self in from the given Read
- fn read(reader: &mut R) -> Result<Option<Self>, DecodeError>;
+ fn read<R: Read>(reader: &mut R) -> Result<Option<Self>, DecodeError>;
}
pub(crate) struct U48(pub u64);
writer.write_all(&be48_to_array(self.0))
}
}
-impl<R: Read> Readable<R> for U48 {
+impl Readable for U48 {
#[inline]
- fn read(reader: &mut R) -> Result<U48, DecodeError> {
+ fn read<R: Read>(reader: &mut R) -> Result<U48, DecodeError> {
let mut buf = [0; 6];
reader.read_exact(&mut buf)?;
Ok(U48(slice_to_be48(&buf)))
}
}
}
-impl<R: Read> Readable<R> for BigSize {
+impl Readable for BigSize {
#[inline]
- fn read(reader: &mut R) -> Result<BigSize, DecodeError> {
+ fn read<R: Read>(reader: &mut R) -> Result<BigSize, DecodeError> {
let n: u8 = Readable::read(reader)?;
match n {
0xFF => {
writer.write_all(&$meth_write(self.0)[(self.0.leading_zeros()/8) as usize..$len])
}
}
- impl<R: Read> Readable<R> for $val_type {
+ impl Readable for $val_type {
#[inline]
- fn read(reader: &mut R) -> Result<$val_type, DecodeError> {
+ fn read<R: Read>(reader: &mut R) -> Result<$val_type, DecodeError> {
let mut buf = [0; $len];
reader.read_exact(&mut buf)?;
Ok($meth_read(&buf))
}
}
- impl<R: Read> Readable<R> for HighZeroBytesDroppedVarInt<$val_type> {
+ impl Readable for HighZeroBytesDroppedVarInt<$val_type> {
#[inline]
- fn read(reader: &mut R) -> Result<HighZeroBytesDroppedVarInt<$val_type>, DecodeError> {
+ fn read<R: Read>(reader: &mut R) -> Result<HighZeroBytesDroppedVarInt<$val_type>, DecodeError> {
// We need to accept short reads (read_len == 0) as "EOF" and handle them as simply
// the high bytes being dropped. To do so, we start reading into the middle of buf
// and then convert the appropriate number of bytes with extra high bytes out of
writer.write_all(&[*self])
}
}
-impl<R: Read> Readable<R> for u8 {
+impl Readable for u8 {
#[inline]
- fn read(reader: &mut R) -> Result<u8, DecodeError> {
+ fn read<R: Read>(reader: &mut R) -> Result<u8, DecodeError> {
let mut buf = [0; 1];
reader.read_exact(&mut buf)?;
Ok(buf[0])
writer.write_all(&[if *self {1} else {0}])
}
}
-impl<R: Read> Readable<R> for bool {
+impl Readable for bool {
#[inline]
- fn read(reader: &mut R) -> Result<bool, DecodeError> {
+ fn read<R: Read>(reader: &mut R) -> Result<bool, DecodeError> {
let mut buf = [0; 1];
reader.read_exact(&mut buf)?;
if buf[0] != 0 && buf[0] != 1 {
}
}
- impl<R: Read> Readable<R> for [u8; $size]
+ impl Readable for [u8; $size]
{
#[inline]
- fn read(r: &mut R) -> Result<Self, DecodeError> {
+ fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
let mut buf = [0u8; $size];
r.read_exact(&mut buf)?;
Ok(buf)
}
}
-impl<R, K, V> Readable<R> for HashMap<K, V>
- where R: Read,
- K: Readable<R> + Eq + Hash,
- V: Readable<R>
+impl<K, V> Readable for HashMap<K, V>
+ where K: Readable + Eq + Hash,
+ V: Readable
{
#[inline]
- fn read(r: &mut R) -> Result<Self, DecodeError> {
+ fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
let len: u16 = Readable::read(r)?;
let mut ret = HashMap::with_capacity(len as usize);
for _ in 0..len {
}
}
-impl<R: Read> Readable<R> for Vec<u8> {
+impl Readable for Vec<u8> {
#[inline]
- fn read(r: &mut R) -> Result<Self, DecodeError> {
+ fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
let len: u16 = Readable::read(r)?;
let mut ret = Vec::with_capacity(len as usize);
ret.resize(len as usize, 0);
}
}
-impl<R: Read> Readable<R> for Vec<Signature> {
+impl Readable for Vec<Signature> {
#[inline]
- fn read(r: &mut R) -> Result<Self, DecodeError> {
+ fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
let len: u16 = Readable::read(r)?;
let byte_size = (len as usize)
.checked_mul(33)
}
}
-impl<R: Read> Readable<R> for Script {
- fn read(r: &mut R) -> Result<Self, DecodeError> {
- let len = <u16 as Readable<R>>::read(r)? as usize;
+impl Readable for Script {
+ fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+ let len = <u16 as Readable>::read(r)? as usize;
let mut buf = vec![0; len];
r.read_exact(&mut buf)?;
Ok(Script::from(buf))
}
}
-impl<R: Read> Readable<R> for PublicKey {
- fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for PublicKey {
+ fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
let buf: [u8; 33] = Readable::read(r)?;
match PublicKey::from_slice(&buf) {
Ok(key) => Ok(key),
}
}
-impl<R: Read> Readable<R> for SecretKey {
- fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for SecretKey {
+ fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
let buf: [u8; 32] = Readable::read(r)?;
match SecretKey::from_slice(&buf) {
Ok(key) => Ok(key),
}
}
-impl<R: Read> Readable<R> for Sha256dHash {
- fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for Sha256dHash {
+ fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
use bitcoin_hashes::Hash;
let buf: [u8; 32] = Readable::read(r)?;
}
}
-impl<R: Read> Readable<R> for Signature {
- fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for Signature {
+ fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
let buf: [u8; 64] = Readable::read(r)?;
match Signature::from_compact(&buf) {
Ok(sig) => Ok(sig),
}
}
-impl<R: Read> Readable<R> for PaymentPreimage {
- fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for PaymentPreimage {
+ fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
let buf: [u8; 32] = Readable::read(r)?;
Ok(PaymentPreimage(buf))
}
}
}
-impl<R: Read> Readable<R> for PaymentHash {
- fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for PaymentHash {
+ fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
let buf: [u8; 32] = Readable::read(r)?;
Ok(PaymentHash(buf))
}
match *self {
None => 0u8.write(w)?,
Some(ref data) => {
- 1u8.write(w)?;
+ let mut len_calc = LengthCalculatingWriter(0);
+ data.write(&mut len_calc).expect("No in-memory data may fail to serialize");
+ BigSize(len_calc.0 as u64 + 1).write(w)?;
data.write(w)?;
}
}
}
}
-impl<R, T> Readable<R> for Option<T>
- where R: Read,
- T: Readable<R>
+impl<T: Readable> Readable for Option<T>
{
- fn read(r: &mut R) -> Result<Self, DecodeError> {
- match <u8 as Readable<R>>::read(r)? {
+ fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
+ match BigSize::read(r)?.0 {
0 => Ok(None),
- 1 => Ok(Some(Readable::read(r)?)),
- _ => return Err(DecodeError::InvalidValue),
+ len => {
+ let mut reader = FixedLengthReader::new(r, len - 1);
+ Ok(Some(Readable::read(&mut reader)?))
+ }
}
}
}
}
}
-impl<R: Read> Readable<R> for OutPoint {
- fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl Readable for OutPoint {
+ fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
let txid = Readable::read(r)?;
let vout = Readable::read(r)?;
Ok(OutPoint {
}
}
- impl<R: Read> Readable<R> for $bitcoin_type {
- fn read(r: &mut R) -> Result<Self, DecodeError> {
+ impl Readable for $bitcoin_type {
+ fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
match consensus::encode::Decodable::consensus_decode(r) {
Ok(t) => Ok(t),
Err(consensus::encode::Error::Io(ref e)) if e.kind() == ::std::io::ErrorKind::UnexpectedEof => Err(DecodeError::ShortRead),
impl_consensus_ser!(Transaction);
impl_consensus_ser!(TxOut);
-impl<R: Read, T: Readable<R>> Readable<R> for Mutex<T> {
- fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl<T: Readable> Readable for Mutex<T> {
+ fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
let t: T = Readable::read(r)?;
Ok(Mutex::new(t))
}
}
}
-impl<R: Read, A: Readable<R>, B: Readable<R>> Readable<R> for (A, B) {
- fn read(r: &mut R) -> Result<Self, DecodeError> {
+impl<A: Readable, B: Readable> Readable for (A, B) {
+ fn read<R: Read>(r: &mut R) -> Result<Self, DecodeError> {
let a: A = Readable::read(r)?;
let b: B = Readable::read(r)?;
Ok((a, b))
}
}
- impl<R: ::std::io::Read> ::util::ser::Readable<R> for $st {
- fn read(r: &mut R) -> Result<Self, ::ln::msgs::DecodeError> {
+ impl ::util::ser::Readable for $st {
+ fn read<R: ::std::io::Read>(r: &mut R) -> Result<Self, ::ln::msgs::DecodeError> {
Ok(Self {
$($field: ::util::ser::Readable::read(r)?),*
})
}
}
- impl<R: ::std::io::Read> Readable<R> for $st {
- fn read(r: &mut R) -> Result<Self, DecodeError> {
+ impl ::util::ser::Readable for $st {
+ fn read<R: ::std::io::Read>(r: &mut R) -> Result<Self, DecodeError> {
Ok(Self {
$($field: Readable::read(r)?),*
})
(0xdeadbeef1badbeef, 0x1bad1dea, Some(0x01020304)));
}
- impl<R: Read> Readable<R> for (PublicKey, u64, u64) {
+ impl Readable for (PublicKey, u64, u64) {
#[inline]
- fn read(reader: &mut R) -> Result<(PublicKey, u64, u64), DecodeError> {
+ fn read<R: Read>(reader: &mut R) -> Result<(PublicKey, u64, u64), DecodeError> {
Ok((Readable::read(reader)?, Readable::read(reader)?, Readable::read(reader)?))
}
}