use bitcoin_hashes::sha256d::Hash as Sha256dHash;
use bitcoin::blockdata::script::Script;
+use ln::features::{ChannelFeatures, InitFeatures, NodeFeatures};
+
use std::error::Error;
use std::{cmp, fmt};
use std::io::Read;
use std::result::Result;
-use std::marker::PhantomData;
use util::events;
-use util::ser::{Readable, Writeable, Writer};
+use util::ser::{Readable, Writeable, Writer, FixedLengthReader, HighZeroBytesDroppedVarInt};
use ln::channelmanager::{PaymentPreimage, PaymentHash};
/// A version byte specified something we don't know how to handle.
/// Includes unknown realm byte in an OnionHopData packet
UnknownVersion,
- /// Unknown feature mandating we fail to parse message
+ /// Unknown feature mandating we fail to parse message (eg TLV with an even, unknown type)
UnknownRequiredFeature,
/// Value was invalid, eg a byte which was supposed to be a bool was something other than a 0
/// or 1, a public key/private key/signature was invalid, text wasn't UTF-8, etc
Io(::std::io::Error),
}
-/// The context in which a Feature object appears determines which bits of features the node
-/// supports will be set. We use this when creating our own Feature objects to select which bits to
-/// set and when passing around Feature objects to ensure the bits we're checking for are
-/// available.
-///
-/// This Context represents when the Feature appears in the init message, sent between peers and not
-/// rumored around the P2P network.
-pub struct FeatureContextInit {}
-/// The context in which a Feature object appears determines which bits of features the node
-/// supports will be set. We use this when creating our own Feature objects to select which bits to
-/// set and when passing around Feature objects to ensure the bits we're checking for are
-/// available.
-///
-/// This Context represents when the Feature appears in the node_announcement message, as it is
-/// rumored around the P2P network.
-pub struct FeatureContextNode {}
-/// The context in which a Feature object appears determines which bits of features the node
-/// supports will be set. We use this when creating our own Feature objects to select which bits to
-/// set and when passing around Feature objects to ensure the bits we're checking for are
-/// available.
-///
-/// This Context represents when the Feature appears in the ChannelAnnouncement message, as it is
-/// rumored around the P2P network.
-pub struct FeatureContextChannel {}
-/// The context in which a Feature object appears determines which bits of features the node
-/// supports will be set. We use this when creating our own Feature objects to select which bits to
-/// set and when passing around Feature objects to ensure the bits we're checking for are
-/// available.
-///
-/// This Context represents when the Feature appears in an invoice, used to determine the different
-/// options available for routing a payment.
-///
-/// Note that this is currently unused as invoices come to us via a different crate and are not
-/// native to rust-lightning directly.
-pub struct FeatureContextInvoice {}
-
-/// An internal trait capturing the various future context types
-pub trait FeatureContext {}
-impl FeatureContext for FeatureContextInit {}
-impl FeatureContext for FeatureContextNode {}
-impl FeatureContext for FeatureContextChannel {}
-impl FeatureContext for FeatureContextInvoice {}
-
-/// An internal trait capturing FeatureContextInit and FeatureContextNode
-pub trait FeatureContextInitNode : FeatureContext {}
-impl FeatureContextInitNode for FeatureContextInit {}
-impl FeatureContextInitNode for FeatureContextNode {}
-
-/// Tracks the set of features which a node implements, templated by the context in which it
-/// appears.
-pub struct Features<T: FeatureContext> {
- #[cfg(not(test))]
- /// Note that, for convinience, flags is LITTLE endian (despite being big-endian on the wire)
- flags: Vec<u8>,
- // Used to test encoding of diverse msgs
- #[cfg(test)]
- pub flags: Vec<u8>,
- mark: PhantomData<T>,
-}
-
-impl<T: FeatureContext> Clone for Features<T> {
- fn clone(&self) -> Self {
- Self {
- flags: self.flags.clone(),
- mark: PhantomData,
- }
- }
-}
-impl<T: FeatureContext> PartialEq for Features<T> {
- fn eq(&self, o: &Self) -> bool {
- self.flags.eq(&o.flags)
- }
-}
-impl<T: FeatureContext> fmt::Debug for Features<T> {
- fn fmt(&self, fmt: &mut fmt::Formatter) -> Result<(), fmt::Error> {
- self.flags.fmt(fmt)
- }
-}
-
-/// A feature message as it appears in an init message
-pub type InitFeatures = Features<FeatureContextInit>;
-/// A feature message as it appears in a node_announcement message
-pub type NodeFeatures = Features<FeatureContextNode>;
-/// A feature message as it appears in a channel_announcement message
-pub type ChannelFeatures = Features<FeatureContextChannel>;
-
-impl<T: FeatureContextInitNode> Features<T> {
- /// Create a Features with the features we support
- #[cfg(not(feature = "fuzztarget"))]
- pub(crate) fn supported() -> Features<T> {
- Features {
- flags: vec![2 | 1 << 5],
- mark: PhantomData,
- }
- }
- #[cfg(feature = "fuzztarget")]
- pub fn supported() -> Features<T> {
- Features {
- flags: vec![2 | 1 << 5],
- mark: PhantomData,
- }
- }
-}
-
-impl Features<FeatureContextChannel> {
- /// Create a Features with the features we support
- #[cfg(not(feature = "fuzztarget"))]
- pub(crate) fn supported() -> Features<FeatureContextChannel> {
- Features {
- flags: Vec::new(),
- mark: PhantomData,
- }
- }
- #[cfg(feature = "fuzztarget")]
- pub fn supported() -> Features<FeatureContextChannel> {
- Features {
- flags: Vec::new(),
- mark: PhantomData,
- }
- }
-}
-
-impl<T: FeatureContext> Features<T> {
- /// Create a blank Features with no fetures set
- pub fn empty() -> Features<T> {
- Features {
- flags: Vec::new(),
- mark: PhantomData,
- }
- }
-
- pub(crate) fn requires_unknown_bits(&self) -> bool {
- self.flags.iter().enumerate().any(|(idx, &byte)| {
- ( idx != 0 && (byte & 0x55) != 0 ) || ( idx == 0 && (byte & 0x14) != 0 )
- })
- }
-
- pub(crate) fn supports_unknown_bits(&self) -> bool {
- self.flags.iter().enumerate().any(|(idx, &byte)| {
- ( idx != 0 && byte != 0 ) || ( idx == 0 && (byte & 0xc4) != 0 )
- })
- }
-
- /// The number of bytes required to represent the feaature flags present. This does not include
- /// the length bytes which are included in the serialized form.
- pub(crate) fn byte_count(&self) -> usize {
- self.flags.len()
- }
-
- #[cfg(test)]
- pub(crate) fn set_require_unknown_bits(&mut self) {
- let newlen = cmp::max(2, self.flags.len());
- self.flags.resize(newlen, 0u8);
- self.flags[1] |= 0x40;
- }
-
- #[cfg(test)]
- pub(crate) fn clear_require_unknown_bits(&mut self) {
- let newlen = cmp::max(2, self.flags.len());
- self.flags.resize(newlen, 0u8);
- self.flags[1] &= !0x40;
- if self.flags.len() == 2 && self.flags[1] == 0 {
- self.flags.resize(1, 0u8);
- }
- }
-}
-
-impl<T: FeatureContextInitNode> Features<T> {
- pub(crate) fn supports_data_loss_protect(&self) -> bool {
- self.flags.len() > 0 && (self.flags[0] & 3) != 0
- }
-
- pub(crate) fn supports_upfront_shutdown_script(&self) -> bool {
- self.flags.len() > 0 && (self.flags[0] & (3 << 4)) != 0
- }
- #[cfg(test)]
- pub(crate) fn unset_upfront_shutdown_script(&mut self) {
- self.flags[0] ^= 1 << 5;
- }
-}
-
-impl Features<FeatureContextInit> {
- pub(crate) fn initial_routing_sync(&self) -> bool {
- self.flags.len() > 0 && (self.flags[0] & (1 << 3)) != 0
- }
- pub(crate) fn set_initial_routing_sync(&mut self) {
- if self.flags.len() == 0 {
- self.flags.resize(1, 1 << 3);
- } else {
- self.flags[0] |= 1 << 3;
- }
- }
-
- /// Writes all features present up to, and including, 13.
- pub(crate) fn write_up_to_13<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
- let len = cmp::min(2, self.flags.len());
- w.size_hint(len + 2);
- (len as u16).write(w)?;
- for i in (0..len).rev() {
- if i == 0 {
- self.flags[i].write(w)?;
- } else {
- (self.flags[i] & ((1 << (14 - 8)) - 1)).write(w)?;
- }
- }
- Ok(())
- }
-
- /// or's another InitFeatures into this one.
- pub(crate) fn or(&mut self, o: &InitFeatures) {
- let total_feature_len = cmp::max(self.flags.len(), o.flags.len());
- self.flags.resize(total_feature_len, 0u8);
- for (feature, o_feature) in self.flags.iter_mut().zip(o.flags.iter()) {
- *feature |= *o_feature;
- }
- }
-}
-
-impl<T: FeatureContext> Writeable for Features<T> {
- fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
- w.size_hint(self.flags.len() + 2);
- (self.flags.len() as u16).write(w)?;
- for f in self.flags.iter().rev() { // We have to swap the endianness back to BE for writing
- f.write(w)?;
- }
- Ok(())
- }
-}
-
-impl<R: ::std::io::Read, T: FeatureContext> Readable<R> for Features<T> {
- fn read(r: &mut R) -> Result<Self, DecodeError> {
- let mut flags: Vec<u8> = Readable::read(r)?;
- flags.reverse(); // Swap to big-endian
- Ok(Self {
- flags,
- mark: PhantomData,
- })
- }
-}
-
/// An init message to be sent or received from a peer
pub struct Init {
+ #[cfg(not(feature = "fuzztarget"))]
pub(crate) features: InitFeatures,
+ #[cfg(feature = "fuzztarget")]
+ pub features: InitFeatures,
}
/// An error message to be sent or received from a peer
/// A funding_locked message to be sent or received from a peer
#[derive(Clone, PartialEq)]
+#[allow(missing_docs)]
pub struct FundingLocked {
- pub(crate) channel_id: [u8; 32],
- pub(crate) next_per_commitment_point: PublicKey,
+ pub channel_id: [u8; 32],
+ pub next_per_commitment_point: PublicKey,
}
/// A shutdown message to be sent or received from a peer
}
}
+/// A "set" of addresses which enforces that there can be only up to one of each net address type.
+pub struct NetAddressSet {
+ v4: Option<NetAddress>,
+ v6: Option<NetAddress>,
+ onion2: Option<NetAddress>,
+ onion3: Option<NetAddress>,
+}
+impl NetAddressSet {
+ /// Creates a new, empty, NetAddressSet
+ pub fn new() -> Self {
+ NetAddressSet { v4: None, v6: None, onion2: None, onion3: None }
+ }
+
+ /// Sets the IPv4 socket address in this set, overwriting any previous IPv4 socket addresses
+ /// (if any).
+ pub fn set_v4(&mut self, addr: [u8; 4], port: u16) {
+ self.v4 = Some(NetAddress::IPv4 { addr, port });
+ }
+ /// Sets the IPv6 socket address in this set, overwriting any previous IPv4 socket addresses
+ /// (if any).
+ pub fn set_v6(&mut self, addr: [u8; 16], port: u16) {
+ self.v6 = Some(NetAddress::IPv6 { addr, port });
+ }
+ /// Sets the Tor Onion v2 socket address in this set, overwriting any previous IPv4 socket
+ /// address (if any).
+ pub fn set_onion_v2(&mut self, addr: [u8; 10], port: u16) {
+ self.onion2 = Some(NetAddress::OnionV2 { addr, port });
+ }
+ /// Sets the Tor Onion v3 socket address in this set, overwriting any previous IPv4 socket
+ /// address (if any).
+ pub fn set_onion_v3(&mut self, ed25519_pubkey: [u8; 32], checksum: u16, version: u8, port: u16) {
+ self.onion3 = Some(NetAddress::OnionV3 { ed25519_pubkey, checksum, version, port });
+ }
+
+ pub(crate) fn to_vec(mut self) -> Vec<NetAddress> {
+ let mut res = Vec::new();
+ if let Some(addr) = self.v4.take() {
+ res.push(addr);
+ }
+ if let Some(addr) = self.v6.take() {
+ res.push(addr);
+ }
+ if let Some(addr) = self.onion2.take() {
+ res.push(addr);
+ }
+ if let Some(addr) = self.onion3.take() {
+ res.push(addr);
+ }
+ res
+ }
+}
+
impl Writeable for NetAddress {
fn write<W: Writer>(&self, writer: &mut W) -> Result<(), ::std::io::Error> {
match self {
fn peer_disconnected(&self, their_node_id: &PublicKey, no_connection_possible: bool);
/// Handle a peer reconnecting, possibly generating channel_reestablish message(s).
- fn peer_connected(&self, their_node_id: &PublicKey);
+ fn peer_connected(&self, their_node_id: &PublicKey, msg: &Init);
/// Handle an incoming channel_reestablish message from the given peer.
fn handle_channel_reestablish(&self, their_node_id: &PublicKey, msg: &ChannelReestablish);
fn get_next_node_announcements(&self, starting_point: Option<&PublicKey>, batch_amount: u8) -> Vec<NodeAnnouncement>;
}
-pub(crate) struct OnionRealm0HopData {
- pub(crate) short_channel_id: u64,
- pub(crate) amt_to_forward: u64,
- pub(crate) outgoing_cltv_value: u32,
- // 12 bytes of 0-padding
-}
-
mod fuzzy_internal_msgs {
// These types aren't intended to be pub, but are exposed for direct fuzzing (as we deserialize
// them from untrusted input):
+ #[derive(Clone)]
+ pub(crate) struct FinalOnionHopData {
+ pub(crate) payment_secret: [u8; 32],
+ pub(crate) total_msat: u64,
+ }
+
+ pub(crate) enum OnionHopDataFormat {
+ Legacy { // aka Realm-0
+ short_channel_id: u64,
+ },
+ NonFinalNode {
+ short_channel_id: u64,
+ },
+ FinalNode {
+ payment_data: Option<FinalOnionHopData>,
+ },
+ }
- use super::OnionRealm0HopData;
pub struct OnionHopData {
- pub(crate) realm: u8,
- pub(crate) data: OnionRealm0HopData,
- pub(crate) hmac: [u8; 32],
+ pub(crate) format: OnionHopDataFormat,
+ pub(crate) amt_to_forward: u64,
+ pub(crate) outgoing_cltv_value: u32,
+ // 12 bytes of 0-padding for Legacy format
}
pub struct DecodedOnionErrorPacket {
impl<R: Read> Readable<R> for Init {
fn read(r: &mut R) -> Result<Self, DecodeError> {
let global_features: InitFeatures = Readable::read(r)?;
- let mut features: InitFeatures = Readable::read(r)?;
- features.or(&global_features);
+ let features: InitFeatures = Readable::read(r)?;
Ok(Init {
- features
+ features: features.or(global_features),
})
}
}
onion_routing_packet
});
-impl Writeable for OnionRealm0HopData {
- fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
- w.size_hint(32);
- self.short_channel_id.write(w)?;
- self.amt_to_forward.write(w)?;
- self.outgoing_cltv_value.write(w)?;
- w.write_all(&[0;12])?;
- Ok(())
- }
-}
-
-impl<R: Read> Readable<R> for OnionRealm0HopData {
- fn read(r: &mut R) -> Result<Self, DecodeError> {
- Ok(OnionRealm0HopData {
- short_channel_id: Readable::read(r)?,
- amt_to_forward: Readable::read(r)?,
- outgoing_cltv_value: {
- let v: u32 = Readable::read(r)?;
- r.read_exact(&mut [0; 12])?;
- v
- }
- })
- }
-}
+impl_writeable!(FinalOnionHopData, 32+8, {
+ payment_secret,
+ total_msat
+});
impl Writeable for OnionHopData {
fn write<W: Writer>(&self, w: &mut W) -> Result<(), ::std::io::Error> {
- w.size_hint(65);
- self.realm.write(w)?;
- self.data.write(w)?;
- self.hmac.write(w)?;
+ w.size_hint(33);
+ match self.format {
+ OnionHopDataFormat::Legacy { short_channel_id } => {
+ 0u8.write(w)?;
+ short_channel_id.write(w)?;
+ self.amt_to_forward.write(w)?;
+ self.outgoing_cltv_value.write(w)?;
+ },
+ OnionHopDataFormat::NonFinalNode { short_channel_id } => {
+ encode_varint_length_prefixed_tlv!(w, {
+ (2, HighZeroBytesDroppedVarInt(self.amt_to_forward)),
+ (4, HighZeroBytesDroppedVarInt(self.outgoing_cltv_value)),
+ (6, short_channel_id)
+ });
+ },
+ OnionHopDataFormat::FinalNode { ref payment_data } => {
+ if let &Some(ref final_data) = payment_data {
+ encode_varint_length_prefixed_tlv!(w, {
+ (2, HighZeroBytesDroppedVarInt(self.amt_to_forward)),
+ (4, HighZeroBytesDroppedVarInt(self.outgoing_cltv_value)),
+ (8, final_data)
+ });
+ } else {
+ encode_varint_length_prefixed_tlv!(w, {
+ (2, HighZeroBytesDroppedVarInt(self.amt_to_forward)),
+ (4, HighZeroBytesDroppedVarInt(self.outgoing_cltv_value))
+ });
+ }
+ },
+ }
+ match self.format {
+ OnionHopDataFormat::Legacy { .. } => {
+ w.write_all(&[0;12])?;
+ },
+ _ => {},
+ }
Ok(())
}
}
impl<R: Read> Readable<R> for OnionHopData {
- fn read(r: &mut R) -> Result<Self, DecodeError> {
- Ok(OnionHopData {
- realm: {
- let r: u8 = Readable::read(r)?;
- if r != 0 {
- return Err(DecodeError::UnknownVersion);
+ fn 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 {
+ Error::Io(ioe) => DecodeError::from(ioe),
+ _ => DecodeError::InvalidValue
+ })?;
+ let (format, amt, cltv_value) = if v.0 != 0 {
+ let mut rd = FixedLengthReader::new(r, v.0);
+ let mut amt = HighZeroBytesDroppedVarInt(0u64);
+ let mut cltv_value = HighZeroBytesDroppedVarInt(0u32);
+ let mut short_id: Option<u64> = None;
+ let mut payment_data: Option<FinalOnionHopData> = None;
+ decode_tlv!(&mut rd, {
+ (2, amt),
+ (4, cltv_value)
+ }, {
+ (6, short_id),
+ (8, payment_data)
+ });
+ rd.eat_remaining().map_err(|_| DecodeError::ShortRead)?;
+ let format = if let Some(short_channel_id) = short_id {
+ if payment_data.is_some() { return Err(DecodeError::InvalidValue); }
+ OnionHopDataFormat::NonFinalNode {
+ short_channel_id,
}
- r
- },
- data: Readable::read(r)?,
- hmac: Readable::read(r)?,
+ } else {
+ OnionHopDataFormat::FinalNode {
+ payment_data
+ }
+ };
+ (format, amt.0, cltv_value.0)
+ } else {
+ let format = OnionHopDataFormat::Legacy {
+ short_channel_id: Readable::read(r)?,
+ };
+ let amt: u64 = Readable::read(r)?;
+ let cltv_value: u32 = Readable::read(r)?;
+ r.read_exact(&mut [0; 12])?;
+ (format, amt, cltv_value)
+ };
+
+ Ok(OnionHopData {
+ format,
+ amt_to_forward: amt,
+ outgoing_cltv_value: cltv_value,
})
}
}
mod tests {
use hex;
use ln::msgs;
- use ln::msgs::{ChannelFeatures, InitFeatures, NodeFeatures, OptionalField, OnionErrorPacket};
+ use ln::msgs::{ChannelFeatures, InitFeatures, NodeFeatures, OptionalField, OnionErrorPacket, OnionHopDataFormat};
use ln::channelmanager::{PaymentPreimage, PaymentHash};
- use util::ser::Writeable;
+ use util::ser::{Writeable, Readable};
use bitcoin_hashes::sha256d::Hash as Sha256dHash;
use bitcoin_hashes::hex::FromHex;
use secp256k1::key::{PublicKey,SecretKey};
use secp256k1::{Secp256k1, Message};
- use std::marker::PhantomData;
+ use std::io::Cursor;
#[test]
fn encoding_channel_reestablish_no_secret() {
let sig_4 = get_sig_on!(privkey_4, secp_ctx, String::from("01010101010101010101010101010101"));
let mut features = ChannelFeatures::supported();
if unknown_features_bits {
- features.flags = vec![0xFF, 0xFF];
+ features = ChannelFeatures::from_le_bytes(vec![0xFF, 0xFF]);
}
let unsigned_channel_announcement = msgs::UnsignedChannelAnnouncement {
features,
let secp_ctx = Secp256k1::new();
let (privkey_1, pubkey_1) = get_keys_from!("0101010101010101010101010101010101010101010101010101010101010101", secp_ctx);
let sig_1 = get_sig_on!(privkey_1, secp_ctx, String::from("01010101010101010101010101010101"));
- let mut features = NodeFeatures::empty();
- if unknown_features_bits {
- features.flags = vec![0xFF, 0xFF];
+ let features = if unknown_features_bits {
+ NodeFeatures::from_le_bytes(vec![0xFF, 0xFF])
} else {
// Set to some features we may support
- features.flags = vec![2 | 1 << 5];
- }
+ NodeFeatures::from_le_bytes(vec![2 | 1 << 5])
+ };
let mut addresses = Vec::new();
if ipv4 {
addresses.push(msgs::NetAddress::IPv4 {
#[test]
fn encoding_init() {
assert_eq!(msgs::Init {
- features: InitFeatures {
- flags: vec![0xFF, 0xFF, 0xFF],
- mark: PhantomData,
- },
+ features: InitFeatures::from_le_bytes(vec![0xFF, 0xFF, 0xFF]),
}.encode(), hex::decode("00023fff0003ffffff").unwrap());
assert_eq!(msgs::Init {
- features: InitFeatures {
- flags: vec![0xFF],
- mark: PhantomData,
- },
+ features: InitFeatures::from_le_bytes(vec![0xFF]),
}.encode(), hex::decode("0001ff0001ff").unwrap());
assert_eq!(msgs::Init {
- features: InitFeatures {
- flags: vec![],
- mark: PhantomData,
- },
+ features: InitFeatures::from_le_bytes(vec![]),
}.encode(), hex::decode("00000000").unwrap());
}
let target_value = hex::decode("004000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000").unwrap();
assert_eq!(encoded_value, target_value);
}
+
+ #[test]
+ fn encoding_legacy_onion_hop_data() {
+ let msg = msgs::OnionHopData {
+ format: OnionHopDataFormat::Legacy {
+ short_channel_id: 0xdeadbeef1bad1dea,
+ },
+ amt_to_forward: 0x0badf00d01020304,
+ outgoing_cltv_value: 0xffffffff,
+ };
+ let encoded_value = msg.encode();
+ let target_value = hex::decode("00deadbeef1bad1dea0badf00d01020304ffffffff000000000000000000000000").unwrap();
+ assert_eq!(encoded_value, target_value);
+ }
+
+ #[test]
+ fn encoding_nonfinal_onion_hop_data() {
+ let mut msg = msgs::OnionHopData {
+ format: OnionHopDataFormat::NonFinalNode {
+ short_channel_id: 0xdeadbeef1bad1dea,
+ },
+ amt_to_forward: 0x0badf00d01020304,
+ outgoing_cltv_value: 0xffffffff,
+ };
+ let encoded_value = msg.encode();
+ let target_value = hex::decode("1a02080badf00d010203040404ffffffff0608deadbeef1bad1dea").unwrap();
+ assert_eq!(encoded_value, target_value);
+ msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
+ if let OnionHopDataFormat::NonFinalNode { short_channel_id } = msg.format {
+ assert_eq!(short_channel_id, 0xdeadbeef1bad1dea);
+ } else { panic!(); }
+ assert_eq!(msg.amt_to_forward, 0x0badf00d01020304);
+ assert_eq!(msg.outgoing_cltv_value, 0xffffffff);
+ }
+
+ #[test]
+ fn encoding_final_onion_hop_data() {
+ let mut msg = msgs::OnionHopData {
+ format: OnionHopDataFormat::FinalNode {
+ payment_data: None,
+ },
+ amt_to_forward: 0x0badf00d01020304,
+ outgoing_cltv_value: 0xffffffff,
+ };
+ let encoded_value = msg.encode();
+ let target_value = hex::decode("1002080badf00d010203040404ffffffff").unwrap();
+ assert_eq!(encoded_value, target_value);
+ msg = Readable::read(&mut Cursor::new(&target_value[..])).unwrap();
+ if let OnionHopDataFormat::FinalNode { payment_data: None } = msg.format { } else { panic!(); }
+ assert_eq!(msg.amt_to_forward, 0x0badf00d01020304);
+ assert_eq!(msg.outgoing_cltv_value, 0xffffffff);
+ }
}