Merge pull request #9623 from Roasbeef/size-msg-test-msg

Size msg test msg

.gitignore

@@ -80,3 +80,5 @@ coverage.txt
 # Release build directory (to avoid build.vcs.modified Golang build tag to be
 # set to true by having untracked files in the working directory).
 /lnd-*/
+
+.aider*

lnwire/accept_channel.go

@@ -128,6 +128,10 @@ type AcceptChannel struct {
 // interface.
 var _ Message = (*AcceptChannel)(nil)
 
+// A compile time check to ensure AcceptChannel implements the
+// lnwire.SizeableMessage interface.
+var _ SizeableMessage = (*AcceptChannel)(nil)
+
 // Encode serializes the target AcceptChannel into the passed io.Writer
 // implementation. Serialization will observe the rules defined by the passed
 // protocol version.
@@ -281,3 +285,10 @@ func (a *AcceptChannel) Decode(r io.Reader, pver uint32) error {
 func (a *AcceptChannel) MsgType() MessageType {
 	return MsgAcceptChannel
 }
+
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (a *AcceptChannel) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(a)
+}

lnwire/announcement_signatures.go

@@ -47,6 +47,10 @@ type AnnounceSignatures1 struct {
 // lnwire.Message interface.
 var _ Message = (*AnnounceSignatures1)(nil)
 
+// A compile time check to ensure AnnounceSignatures1 implements the
+// lnwire.SizeableMessage interface.
+var _ SizeableMessage = (*AnnounceSignatures1)(nil)
+
 // A compile time check to ensure AnnounceSignatures1 implements the
 // lnwire.AnnounceSignatures interface.
 var _ AnnounceSignatures = (*AnnounceSignatures1)(nil)
@@ -97,6 +101,13 @@ func (a *AnnounceSignatures1) MsgType() MessageType {
 	return MsgAnnounceSignatures
 }
 
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (a *AnnounceSignatures1) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(a)
+}
+
 // SCID returns the ShortChannelID of the channel.
 //
 // This is part of the lnwire.AnnounceSignatures interface.

lnwire/announcement_signatures_2.go

@@ -41,6 +41,10 @@ type AnnounceSignatures2 struct {
 // lnwire.Message interface.
 var _ Message = (*AnnounceSignatures2)(nil)
 
+// A compile time check to ensure AnnounceSignatures2 implements the
+// lnwire.SizeableMessage interface.
+var _ SizeableMessage = (*AnnounceSignatures2)(nil)
+
 // Decode deserializes a serialized AnnounceSignatures2 stored in the passed
 // io.Reader observing the specified protocol version.
 //
@@ -82,6 +86,13 @@ func (a *AnnounceSignatures2) MsgType() MessageType {
 	return MsgAnnounceSignatures2
 }
 
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (a *AnnounceSignatures2) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(a)
+}
+
 // SCID returns the ShortChannelID of the channel.
 //
 // NOTE: this is part of the AnnounceSignatures interface.

lnwire/channel_announcement.go

@@ -62,6 +62,10 @@ type ChannelAnnouncement1 struct {
 // lnwire.Message interface.
 var _ Message = (*ChannelAnnouncement1)(nil)
 
+// A compile time check to ensure ChannelAnnouncement1 implements the
+// lnwire.SizeableMessage interface.
+var _ SizeableMessage = (*ChannelAnnouncement1)(nil)
+
 // Decode deserializes a serialized ChannelAnnouncement stored in the passed
 // io.Reader observing the specified protocol version.
 //
@@ -143,6 +147,13 @@ func (a *ChannelAnnouncement1) MsgType() MessageType {
 	return MsgChannelAnnouncement
 }
 
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (a *ChannelAnnouncement1) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(a)
+}
+
 // DataToSign is used to retrieve part of the announcement message which should
 // be signed.
 func (a *ChannelAnnouncement1) DataToSign() ([]byte, error) {

lnwire/channel_announcement_2.go

@@ -194,10 +194,21 @@ func (c *ChannelAnnouncement2) MsgType() MessageType {
 	return MsgChannelAnnouncement2
 }
 
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (c *ChannelAnnouncement2) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(c)
+}
+
 // A compile time check to ensure ChannelAnnouncement2 implements the
 // lnwire.Message interface.
 var _ Message = (*ChannelAnnouncement2)(nil)
 
+// A compile time check to ensure ChannelAnnouncement2 implements the
+// lnwire.SizeableMessage interface.
+var _ SizeableMessage = (*ChannelAnnouncement2)(nil)
+
 // Node1KeyBytes returns the bytes representing the public key of node 1 in the
 // channel.
 //

lnwire/channel_ready.go

@@ -63,6 +63,10 @@ func NewChannelReady(cid ChannelID, npcp *btcec.PublicKey) *ChannelReady {
 // interface.
 var _ Message = (*ChannelReady)(nil)
 
+// A compile time check to ensure ChannelReady implements the
+// lnwire.SizeableMessage interface.
+var _ SizeableMessage = (*ChannelReady)(nil)
+
 // Decode deserializes the serialized ChannelReady message stored in the
 // passed io.Reader into the target ChannelReady using the deserialization
 // rules defined by the passed protocol version.
@@ -170,3 +174,10 @@ func (c *ChannelReady) Encode(w *bytes.Buffer, _ uint32) error {
 func (c *ChannelReady) MsgType() MessageType {
 	return MsgChannelReady
 }
+
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (c *ChannelReady) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(c)
+}

lnwire/channel_reestablish.go

@@ -99,6 +99,10 @@ type ChannelReestablish struct {
 // lnwire.Message interface.
 var _ Message = (*ChannelReestablish)(nil)
 
+// A compile time check to ensure ChannelReestablish implements the
+// lnwire.SizeableMessage interface.
+var _ SizeableMessage = (*ChannelReestablish)(nil)
+
 // Encode serializes the target ChannelReestablish into the passed io.Writer
 // observing the protocol version specified.
 //
@@ -234,3 +238,10 @@ func (a *ChannelReestablish) Decode(r io.Reader, pver uint32) error {
 func (a *ChannelReestablish) MsgType() MessageType {
 	return MsgChannelReestablish
 }
+
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (a *ChannelReestablish) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(a)
+}

lnwire/channel_update.go

@@ -124,6 +124,10 @@ type ChannelUpdate1 struct {
 // interface.
 var _ Message = (*ChannelUpdate1)(nil)
 
+// A compile time check to ensure ChannelUpdate1 implements the
+// lnwire.SizeableMessage interface.
+var _ SizeableMessage = (*ChannelUpdate1)(nil)
+
 // Decode deserializes a serialized ChannelUpdate stored in the passed
 // io.Reader observing the specified protocol version.
 //
@@ -367,3 +371,10 @@ func (a *ChannelUpdate1) SetSCID(scid ShortChannelID) {
 // A compile time assertion to ensure ChannelUpdate1 implements the
 // ChannelUpdate interface.
 var _ ChannelUpdate = (*ChannelUpdate1)(nil)
+
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (a *ChannelUpdate1) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(a)
+}

lnwire/channel_update_2.go

@@ -241,6 +241,13 @@ func (c *ChannelUpdate2) MsgType() MessageType {
 	return MsgChannelUpdate2
 }
 
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (c *ChannelUpdate2) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(c)
+}
+
 func (c *ChannelUpdate2) ExtraData() ExtraOpaqueData {
 	return c.ExtraOpaqueData
 }

lnwire/closing_complete.go

@@ -169,6 +169,17 @@ func (c *ClosingComplete) MsgType() MessageType {
 	return MsgClosingComplete
 }
 
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (c *ClosingComplete) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(c)
+}
+
 // A compile time check to ensure ClosingComplete implements the lnwire.Message
 // interface.
 var _ Message = (*ClosingComplete)(nil)
+
+// A compile time check to ensure ClosingComplete implements the
+// lnwire.SizeableMessage interface.
+var _ SizeableMessage = (*ClosingComplete)(nil)

lnwire/closing_sig.go

@@ -107,6 +107,17 @@ func (c *ClosingSig) MsgType() MessageType {
 	return MsgClosingSig
 }
 
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (c *ClosingSig) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(c)
+}
+
 // A compile time check to ensure ClosingSig implements the lnwire.Message
 // interface.
 var _ Message = (*ClosingSig)(nil)
+
+// A compile time check to ensure ClosingSig implements the
+// lnwire.SizeableMessage interface.
+var _ SizeableMessage = (*ClosingSig)(nil)

lnwire/closing_signed.go

@@ -59,6 +59,10 @@ func NewClosingSigned(cid ChannelID, fs btcutil.Amount,
 // interface.
 var _ Message = (*ClosingSigned)(nil)
 
+// A compile time check to ensure ClosingSigned implements the
+// lnwire.SizeableMessage interface.
+var _ SizeableMessage = (*ClosingSigned)(nil)
+
 // Decode deserializes a serialized ClosingSigned message stored in the passed
 // io.Reader observing the specified protocol version.
 //
@@ -130,3 +134,10 @@ func (c *ClosingSigned) Encode(w *bytes.Buffer, pver uint32) error {
 func (c *ClosingSigned) MsgType() MessageType {
 	return MsgClosingSigned
 }
+
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (c *ClosingSigned) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(c)
+}

lnwire/commit_sig.go

@@ -64,6 +64,10 @@ func NewCommitSig() *CommitSig {
 // interface.
 var _ Message = (*CommitSig)(nil)
 
+// A compile time check to ensure CommitSig implements the
+// lnwire.SizeableMessage interface.
+var _ SizeableMessage = (*CommitSig)(nil)
+
 // Decode deserializes a serialized CommitSig message stored in the
 // passed io.Reader observing the specified protocol version.
 //
@@ -151,3 +155,10 @@ func (c *CommitSig) MsgType() MessageType {
 func (c *CommitSig) TargetChanID() ChannelID {
 	return c.ChanID
 }
+
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (c *CommitSig) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(c)
+}

lnwire/custom.go

@@ -69,10 +69,14 @@ type Custom struct {
 	Data []byte
 }
 
-// A compile time check to ensure FundingCreated implements the lnwire.Message
+// A compile time check to ensure Custom implements the lnwire.Message
 // interface.
 var _ Message = (*Custom)(nil)
 
+// A compile time check to ensure Custom implements the lnwire.SizeableMessage
+// interface.
+var _ SizeableMessage = (*Custom)(nil)
+
 // NewCustom instantiates a new custom message.
 func NewCustom(msgType MessageType, data []byte) (*Custom, error) {
 	if msgType < CustomTypeStart && !IsCustomOverride(msgType) {
@@ -117,3 +121,10 @@ func (c *Custom) Decode(r io.Reader, pver uint32) error {
 func (c *Custom) MsgType() MessageType {
 	return c.Type
 }
+
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (c *Custom) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(c)
+}

lnwire/dyn_ack.go

@@ -41,6 +41,10 @@ type DynAck struct {
 // interface.
 var _ Message = (*DynAck)(nil)
 
+// A compile time check to ensure DynAck implements the lnwire.SizeableMessage
+// interface.
+var _ SizeableMessage = (*DynAck)(nil)
+
 // Encode serializes the target DynAck into the passed io.Writer. Serialization
 // will observe the rules defined by the passed protocol version.
 //
@@ -136,3 +140,10 @@ func (da *DynAck) Decode(r io.Reader, _ uint32) error {
 func (da *DynAck) MsgType() MessageType {
 	return MsgDynAck
 }
+
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (da *DynAck) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(da)
+}

lnwire/dyn_propose.go

@@ -105,6 +105,10 @@ type DynPropose struct {
 // interface.
 var _ Message = (*DynPropose)(nil)
 
+// A compile time check to ensure DynPropose implements the
+// lnwire.SizeableMessage interface.
+var _ SizeableMessage = (*DynPropose)(nil)
+
 // Encode serializes the target DynPropose into the passed io.Writer.
 // Serialization will observe the rules defined by the passed protocol version.
 //
@@ -317,3 +321,10 @@ func (dp *DynPropose) Decode(r io.Reader, _ uint32) error {
 func (dp *DynPropose) MsgType() MessageType {
 	return MsgDynPropose
 }
+
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (dp *DynPropose) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(dp)
+}

lnwire/dyn_reject.go

@@ -30,6 +30,10 @@ type DynReject struct {
 // interface.
 var _ Message = (*DynReject)(nil)
 
+// A compile time check to ensure DynReject implements the
+// lnwire.SizeableMessage interface.
+var _ SizeableMessage = (*DynReject)(nil)
+
 // Encode serializes the target DynReject into the passed io.Writer.
 // Serialization will observe the rules defined by the passed protocol version.
 //
@@ -74,3 +78,10 @@ func (dr *DynReject) Decode(r io.Reader, _ uint32) error {
 func (dr *DynReject) MsgType() MessageType {
 	return MsgDynReject
 }
+
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (dr *DynReject) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(dr)
+}

lnwire/error.go

@@ -70,6 +70,10 @@ func NewError() *Error {
 // interface.
 var _ Message = (*Error)(nil)
 
+// A compile time check to ensure Error implements the lnwire.SizeableMessage
+// interface.
+var _ SizeableMessage = (*Error)(nil)
+
 // Error returns the string representation to Error.
 //
 // NOTE: Satisfies the error interface.
@@ -113,6 +117,13 @@ func (c *Error) MsgType() MessageType {
 	return MsgError
 }
 
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (c *Error) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(c)
+}
+
 // isASCII is a helper method that checks whether all bytes in `data` would be
 // printable ASCII characters if interpreted as a string.
 func isASCII(data []byte) bool {

lnwire/funding_created.go

@@ -44,6 +44,10 @@ type FundingCreated struct {
 // interface.
 var _ Message = (*FundingCreated)(nil)
 
+// A compile time check to ensure FundingCreated implements the
+// lnwire.SizeableMessage interface.
+var _ SizeableMessage = (*FundingCreated)(nil)
+
 // Encode serializes the target FundingCreated into the passed io.Writer
 // implementation. Serialization will observe the rules defined by the passed
 // protocol version.
@@ -117,3 +121,10 @@ func (f *FundingCreated) Decode(r io.Reader, pver uint32) error {
 func (f *FundingCreated) MsgType() MessageType {
 	return MsgFundingCreated
 }
+
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (f *FundingCreated) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(f)
+}

lnwire/funding_signed.go

@@ -36,6 +36,10 @@ type FundingSigned struct {
 // interface.
 var _ Message = (*FundingSigned)(nil)
 
+// A compile time check to ensure FundingSigned implements the
+// lnwire.SizeableMessage interface.
+var _ SizeableMessage = (*FundingSigned)(nil)
+
 // Encode serializes the target FundingSigned into the passed io.Writer
 // implementation. Serialization will observe the rules defined by the passed
 // protocol version.
@@ -103,3 +107,10 @@ func (f *FundingSigned) Decode(r io.Reader, pver uint32) error {
 func (f *FundingSigned) MsgType() MessageType {
 	return MsgFundingSigned
 }
+
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (f *FundingSigned) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(f)
+}

lnwire/gossip_timestamp_range.go

@@ -58,6 +58,10 @@ func NewGossipTimestampRange() *GossipTimestampRange {
 // lnwire.Message interface.
 var _ Message = (*GossipTimestampRange)(nil)
 
+// A compile time check to ensure GossipTimestampRange implements the
+// lnwire.SizeableMessage interface.
+var _ SizeableMessage = (*GossipTimestampRange)(nil)
+
 // Decode deserializes a serialized GossipTimestampRange message stored in the
 // passed io.Reader observing the specified protocol version.
 //
@@ -143,3 +147,10 @@ func (g *GossipTimestampRange) Encode(w *bytes.Buffer, pver uint32) error {
 func (g *GossipTimestampRange) MsgType() MessageType {
 	return MsgGossipTimestampRange
 }
+
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (g *GossipTimestampRange) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(g)
+}

lnwire/init_message.go

@@ -43,6 +43,10 @@ func NewInitMessage(gf *RawFeatureVector, f *RawFeatureVector) *Init {
 // interface.
 var _ Message = (*Init)(nil)
 
+// A compile time check to ensure Init implements the lnwire.SizeableMessage
+// interface.
+var _ SizeableMessage = (*Init)(nil)
+
 // Decode deserializes a serialized Init message stored in the passed
 // io.Reader observing the specified protocol version.
 //
@@ -78,3 +82,10 @@ func (msg *Init) Encode(w *bytes.Buffer, pver uint32) error {
 func (msg *Init) MsgType() MessageType {
 	return MsgInit
 }
+
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (msg *Init) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(msg)
+}

lnwire/kickoff_sig.go

@@ -27,6 +27,10 @@ type KickoffSig struct {
 // interface.
 var _ Message = (*KickoffSig)(nil)
 
+// A compile time check to ensure KickoffSig implements the
+// lnwire.SizeableMessage interface.
+var _ SizeableMessage = (*KickoffSig)(nil)
+
 // Encode serializes the target KickoffSig into the passed bytes.Buffer
 // observing the specified protocol version.
 //
@@ -54,3 +58,10 @@ func (ks *KickoffSig) Decode(r io.Reader, _ uint32) error {
 //
 // This is part of the lnwire.Message interface.
 func (ks *KickoffSig) MsgType() MessageType { return MsgKickoffSig }
+
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (ks *KickoffSig) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(ks)
+}

lnwire/message.go

@@ -12,6 +12,10 @@ import (
 	"io"
 )
 
+// MessageTypeSize is the size in bytes of the message type field in the header
+// of all messages.
+const MessageTypeSize = 2
+
 // MessageType is the unique 2 byte big-endian integer that indicates the type
 // of message on the wire. All messages have a very simple header which
 // consists simply of 2-byte message type. We omit a length field, and checksum
@@ -61,6 +65,11 @@ const (
 	MsgChannelAnnouncement2                = 267
 	MsgChannelUpdate2                      = 271
 	MsgKickoffSig                          = 777
+
+	// MsgEnd defines the end of the official message range of the protocol.
+	// If a new message is added beyond this message, then this should be
+	// modified.
+	MsgEnd = 778
 )
 
 // IsChannelUpdate is a filter function that discerns channel update messages
@@ -234,6 +243,31 @@ type LinkUpdater interface {
 	TargetChanID() ChannelID
 }
 
+// SizeableMessage is an interface that extends the base Message interface with
+// a method to calculate the serialized size of a message.
+type SizeableMessage interface {
+	Message
+
+	// SerializedSize returns the serialized size of the message in bytes.
+	// The returned size includes the message type header bytes.
+	SerializedSize() (uint32, error)
+}
+
+// MessageSerializedSize calculates the serialized size of a message in bytes.
+// This is a helper function that can be used by all message types to implement
+// the SerializedSize method.
+func MessageSerializedSize(msg Message) (uint32, error) {
+	var buf bytes.Buffer
+
+	// Encode the message to the buffer.
+	if err := msg.Encode(&buf, 0); err != nil {
+		return 0, err
+	}
+
+	// Add the size of the message type.
+	return uint32(buf.Len()) + MessageTypeSize, nil
+}
+
 // makeEmptyMessage creates a new empty message of the proper concrete type
 // based on the passed message type.
 func makeEmptyMessage(msgType MessageType) (Message, error) {
@@ -337,6 +371,12 @@ func makeEmptyMessage(msgType MessageType) (Message, error) {
 	return msg, nil
 }
 
+// MakeEmptyMessage creates a new empty message of the proper concrete type
+// based on the passed message type. This is exported to be used in tests.
+func MakeEmptyMessage(msgType MessageType) (Message, error) {
+	return makeEmptyMessage(msgType)
+}
+
 // WriteMessage writes a lightning Message to a buffer including the necessary
 // header information and returns the number of bytes written. If any error is
 // encountered, the buffer passed will be reset to its original state since we

lnwire/node_announcement.go

@@ -104,6 +104,10 @@ type NodeAnnouncement struct {
 // lnwire.Message interface.
 var _ Message = (*NodeAnnouncement)(nil)
 
+// A compile time check to ensure NodeAnnouncement implements the
+// lnwire.SizeableMessage interface.
+var _ SizeableMessage = (*NodeAnnouncement)(nil)
+
 // Decode deserializes a serialized NodeAnnouncement stored in the passed
 // io.Reader observing the specified protocol version.
 //
@@ -202,3 +206,10 @@ func (a *NodeAnnouncement) DataToSign() ([]byte, error) {
 
 	return buf.Bytes(), nil
 }
+
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (a *NodeAnnouncement) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(a)
+}

lnwire/open_channel.go

@@ -164,6 +164,10 @@ type OpenChannel struct {
 // interface.
 var _ Message = (*OpenChannel)(nil)
 
+// A compile time check to ensure OpenChannel implements the
+// lnwire.SizeableMessage interface.
+var _ SizeableMessage = (*OpenChannel)(nil)
+
 // Encode serializes the target OpenChannel into the passed io.Writer
 // implementation. Serialization will observe the rules defined by the passed
 // protocol version.
@@ -335,3 +339,10 @@ func (o *OpenChannel) Decode(r io.Reader, pver uint32) error {
 func (o *OpenChannel) MsgType() MessageType {
 	return MsgOpenChannel
 }
+
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (o *OpenChannel) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(o)
+}

lnwire/ping.go

@@ -33,6 +33,10 @@ func NewPing(numBytes uint16) *Ping {
 // A compile time check to ensure Ping implements the lnwire.Message interface.
 var _ Message = (*Ping)(nil)
 
+// A compile time check to ensure Ping implements the lnwire.SizeableMessage
+// interface.
+var _ SizeableMessage = (*Ping)(nil)
+
 // Decode deserializes a serialized Ping message stored in the passed io.Reader
 // observing the specified protocol version.
 //
@@ -69,3 +73,10 @@ func (p *Ping) Encode(w *bytes.Buffer, pver uint32) error {
 func (p *Ping) MsgType() MessageType {
 	return MsgPing
 }
+
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (p *Ping) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(p)
+}

lnwire/pong.go

@@ -39,6 +39,10 @@ func NewPong(pongBytes []byte) *Pong {
 // A compile time check to ensure Pong implements the lnwire.Message interface.
 var _ Message = (*Pong)(nil)
 
+// A compile time check to ensure Pong implements the lnwire.SizeableMessage
+// interface.
+var _ SizeableMessage = (*Pong)(nil)
+
 // Decode deserializes a serialized Pong message stored in the passed io.Reader
 // observing the specified protocol version.
 //
@@ -64,3 +68,10 @@ func (p *Pong) Encode(w *bytes.Buffer, pver uint32) error {
 func (p *Pong) MsgType() MessageType {
 	return MsgPong
 }
+
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (p *Pong) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(p)
+}

lnwire/query_channel_range.go

@@ -49,6 +49,10 @@ func NewQueryChannelRange() *QueryChannelRange {
 // lnwire.Message interface.
 var _ Message = (*QueryChannelRange)(nil)
 
+// A compile time check to ensure QueryChannelRange implements the
+// lnwire.SizeableMessage interface.
+var _ SizeableMessage = (*QueryChannelRange)(nil)
+
 // Decode deserializes a serialized QueryChannelRange message stored in the
 // passed io.Reader observing the specified protocol version.
 //
@@ -121,6 +125,14 @@ func (q *QueryChannelRange) MsgType() MessageType {
 	return MsgQueryChannelRange
 }
 
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (q *QueryChannelRange) SerializedSize() (uint32, error) {
+	msgCpy := *q
+	return MessageSerializedSize(&msgCpy)
+}
+
 // LastBlockHeight returns the last block height covered by the range of a
 // QueryChannelRange message.
 func (q *QueryChannelRange) LastBlockHeight() uint32 {

lnwire/query_short_chan_ids.go

@@ -91,6 +91,10 @@ func NewQueryShortChanIDs(h chainhash.Hash, e QueryEncoding,
 // lnwire.Message interface.
 var _ Message = (*QueryShortChanIDs)(nil)
 
+// A compile time check to ensure QueryShortChanIDs implements the
+// lnwire.SizeableMessage interface.
+var _ SizeableMessage = (*QueryShortChanIDs)(nil)
+
 // Decode deserializes a serialized QueryShortChanIDs message stored in the
 // passed io.Reader observing the specified protocol version.
 //
@@ -427,3 +431,10 @@ func encodeShortChanIDs(w *bytes.Buffer, encodingType QueryEncoding,
 func (q *QueryShortChanIDs) MsgType() MessageType {
 	return MsgQueryShortChanIDs
 }
+
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (q *QueryShortChanIDs) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(q)
+}

lnwire/reply_channel_range.go

@@ -70,6 +70,10 @@ func NewReplyChannelRange() *ReplyChannelRange {
 // lnwire.Message interface.
 var _ Message = (*ReplyChannelRange)(nil)
 
+// A compile time check to ensure ReplyChannelRange implements the
+// lnwire.SizeableMessage interface.
+var _ SizeableMessage = (*ReplyChannelRange)(nil)
+
 // Decode deserializes a serialized ReplyChannelRange message stored in the
 // passed io.Reader observing the specified protocol version.
 //
@@ -223,3 +227,10 @@ func (c *ReplyChannelRange) LastBlockHeight() uint32 {
 	}
 	return uint32(lastBlockHeight)
 }
+
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (c *ReplyChannelRange) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(c)
+}

lnwire/reply_short_chan_ids_end.go

@@ -39,6 +39,10 @@ func NewReplyShortChanIDsEnd() *ReplyShortChanIDsEnd {
 // lnwire.Message interface.
 var _ Message = (*ReplyShortChanIDsEnd)(nil)
 
+// A compile time check to ensure ReplyShortChanIDsEnd implements the
+// lnwire.SizeableMessage interface.
+var _ SizeableMessage = (*ReplyShortChanIDsEnd)(nil)
+
 // Decode deserializes a serialized ReplyShortChanIDsEnd message stored in the
 // passed io.Reader observing the specified protocol version.
 //
@@ -74,3 +78,10 @@ func (c *ReplyShortChanIDsEnd) Encode(w *bytes.Buffer, pver uint32) error {
 func (c *ReplyShortChanIDsEnd) MsgType() MessageType {
 	return MsgReplyShortChanIDsEnd
 }
+
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (c *ReplyShortChanIDsEnd) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(c)
+}

lnwire/revoke_and_ack.go

@@ -55,6 +55,10 @@ func NewRevokeAndAck() *RevokeAndAck {
 // interface.
 var _ Message = (*RevokeAndAck)(nil)
 
+// A compile time check to ensure RevokeAndAck implements the
+// lnwire.SizeableMessage interface.
+var _ SizeableMessage = (*RevokeAndAck)(nil)
+
 // Decode deserializes a serialized RevokeAndAck message stored in the
 // passed io.Reader observing the specified protocol version.
 //
@@ -136,3 +140,10 @@ func (c *RevokeAndAck) MsgType() MessageType {
 func (c *RevokeAndAck) TargetChanID() ChannelID {
 	return c.ChanID
 }
+
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (c *RevokeAndAck) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(c)
+}

lnwire/serialized_size_test.go

@@ -0,0 +1,68 @@
+package lnwire
+
+import (
+	"bytes"
+	"math"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+	"pgregory.net/rapid"
+)
+
+// TestSerializedSize uses property-based testing to verify that
+// SerializedSize returns the correct value for randomly generated messages.
+func TestSerializedSize(t *testing.T) {
+	t.Parallel()
+
+	rapid.Check(t, func(t *rapid.T) {
+		// Pick a random message type.
+		msgType := rapid.Custom(func(t *rapid.T) MessageType {
+			return MessageType(
+				rapid.IntRange(
+					0, int(math.MaxUint16),
+				).Draw(t, "msgType"),
+			)
+		}).Draw(t, "msgType")
+
+		// Create an empty message of the given type.
+		m, err := MakeEmptyMessage(msgType)
+
+		// An error means this isn't a valid message type, so we skip
+		// it.
+		if err != nil {
+			return
+		}
+
+		testMsg, ok := m.(TestMessage)
+		require.True(
+			t, ok, "message type %s does not "+
+				"implement TestMessage", msgType,
+		)
+
+		// Use the testMsg to make a new random message.
+		msg := testMsg.RandTestMessage(t)
+
+		// Type assertion to ensure the message implements
+		// SizeableMessage.
+		sizeMsg, ok := msg.(SizeableMessage)
+		require.True(
+			t, ok, "message type %s does not "+
+				"implement SizeableMessage", msgType,
+		)
+
+		// Get the size using SerializedSize.
+		size, err := sizeMsg.SerializedSize()
+		require.NoError(t, err, "SerializedSize error")
+
+		// Get the size by actually serializing the message.
+		var buf bytes.Buffer
+		writtenBytes, err := WriteMessage(&buf, msg, 0)
+		require.NoError(t, err, "WriteMessage error")
+
+		// The SerializedSize should match the number of bytes written.
+		require.Equal(t, uint32(writtenBytes), size,
+			"SerializedSize = %d, actual bytes "+
+				"written = %d for message type %s (populated)",
+			size, writtenBytes, msgType)
+	})
+}

lnwire/shutdown.go

@@ -61,6 +61,10 @@ func NewShutdown(cid ChannelID, addr DeliveryAddress) *Shutdown {
 // interface.
 var _ Message = (*Shutdown)(nil)
 
+// A compile-time check to ensure Shutdown implements the lnwire.SizeableMessage
+// interface.
+var _ SizeableMessage = (*Shutdown)(nil)
+
 // Decode deserializes a serialized Shutdown from the passed io.Reader,
 // observing the specified protocol version.
 //
@@ -133,3 +137,10 @@ func (s *Shutdown) Encode(w *bytes.Buffer, pver uint32) error {
 func (s *Shutdown) MsgType() MessageType {
 	return MsgShutdown
 }
+
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (s *Shutdown) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(s)
+}

lnwire/stfu.go

@@ -24,6 +24,10 @@ type Stfu struct {
 // A compile time check to ensure Stfu implements the lnwire.Message interface.
 var _ Message = (*Stfu)(nil)
 
+// A compile time check to ensure Stfu implements the lnwire.SizeableMessage
+// interface.
+var _ SizeableMessage = (*Stfu)(nil)
+
 // Encode serializes the target Stfu into the passed io.Writer.
 // Serialization will observe the rules defined by the passed protocol version.
 //
@@ -68,6 +72,13 @@ func (s *Stfu) MsgType() MessageType {
 	return MsgStfu
 }
 
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (s *Stfu) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(s)
+}
+
 // A compile time check to ensure Stfu implements the
 // lnwire.LinkUpdater interface.
 var _ LinkUpdater = (*Stfu)(nil)

lnwire/test_utils.go

@@ -0,0 +1,360 @@
+package lnwire
+
+import (
+	"crypto/sha256"
+	"fmt"
+	"net"
+
+	"github.com/btcsuite/btcd/btcec/v2"
+	"github.com/btcsuite/btcd/btcec/v2/ecdsa"
+	"github.com/btcsuite/btcd/chaincfg/chainhash"
+	"github.com/btcsuite/btcd/wire"
+	"github.com/lightningnetwork/lnd/fn/v2"
+	"github.com/stretchr/testify/require"
+	"pgregory.net/rapid"
+)
+
+// RandChannelUpdate generates a random ChannelUpdate message using rapid's
+// generators.
+func RandPartialSig(t *rapid.T) *PartialSig {
+	// Generate random private key bytes
+	sigBytes := rapid.SliceOfN(rapid.Byte(), 32, 32).Draw(t, "privKeyBytes")
+
+	var s btcec.ModNScalar
+	s.SetByteSlice(sigBytes)
+
+	return &PartialSig{
+		Sig: s,
+	}
+}
+
+// RandPartialSigWithNonce generates a random PartialSigWithNonce using rapid
+// generators.
+func RandPartialSigWithNonce(t *rapid.T) *PartialSigWithNonce {
+	sigLen := rapid.IntRange(1, 65).Draw(t, "partialSigLen")
+	sigBytes := rapid.SliceOfN(
+		rapid.Byte(), sigLen, sigLen,
+	).Draw(t, "partialSig")
+
+	sigScalar := new(btcec.ModNScalar)
+	sigScalar.SetByteSlice(sigBytes)
+
+	return NewPartialSigWithNonce(
+		RandMusig2Nonce(t), *sigScalar,
+	)
+}
+
+// RandPubKey generates a random public key using rapid's generators.
+func RandPubKey(t *rapid.T) *btcec.PublicKey {
+	privKeyBytes := rapid.SliceOfN(rapid.Byte(), 32, 32).Draw(
+		t, "privKeyBytes",
+	)
+	_, pub := btcec.PrivKeyFromBytes(privKeyBytes)
+
+	return pub
+}
+
+// RandChannelID generates a random channel ID.
+func RandChannelID(t *rapid.T) ChannelID {
+	var c ChannelID
+	bytes := rapid.SliceOfN(rapid.Byte(), 32, 32).Draw(t, "channelID")
+	copy(c[:], bytes)
+
+	return c
+}
+
+// RandShortChannelID generates a random short channel ID.
+func RandShortChannelID(t *rapid.T) ShortChannelID {
+	return NewShortChanIDFromInt(
+		uint64(rapid.IntRange(1, 100000).Draw(t, "shortChanID")),
+	)
+}
+
+// RandFeatureVector generates a random feature vector.
+func RandFeatureVector(t *rapid.T) *RawFeatureVector {
+	featureVec := NewRawFeatureVector()
+
+	// Add a random number of random feature bits
+	numFeatures := rapid.IntRange(0, 20).Draw(t, "numFeatures")
+	for i := 0; i < numFeatures; i++ {
+		bit := FeatureBit(rapid.IntRange(0, 100).Draw(
+			t, fmt.Sprintf("featureBit-%d", i)),
+		)
+		featureVec.Set(bit)
+	}
+
+	return featureVec
+}
+
+// RandSignature generates a signature for testing.
+func RandSignature(t *rapid.T) Sig {
+	testRScalar := new(btcec.ModNScalar)
+	testSScalar := new(btcec.ModNScalar)
+
+	// Generate random bytes for R and S
+	rBytes := rapid.SliceOfN(rapid.Byte(), 32, 32).Draw(t, "rBytes")
+	sBytes := rapid.SliceOfN(rapid.Byte(), 32, 32).Draw(t, "sBytes")
+	_ = testRScalar.SetByteSlice(rBytes)
+	_ = testSScalar.SetByteSlice(sBytes)
+
+	testSig := ecdsa.NewSignature(testRScalar, testSScalar)
+
+	sig, err := NewSigFromSignature(testSig)
+	if err != nil {
+		panic(fmt.Sprintf("unable to create signature: %v", err))
+	}
+
+	return sig
+}
+
+// RandPaymentHash generates a random payment hash.
+func RandPaymentHash(t *rapid.T) [32]byte {
+	var hash [32]byte
+	bytes := rapid.SliceOfN(rapid.Byte(), 32, 32).Draw(t, "paymentHash")
+	copy(hash[:], bytes)
+
+	return hash
+}
+
+// RandPaymentPreimage generates a random payment preimage.
+func RandPaymentPreimage(t *rapid.T) [32]byte {
+	var preimage [32]byte
+	bytes := rapid.SliceOfN(rapid.Byte(), 32, 32).Draw(t, "preimage")
+	copy(preimage[:], bytes)
+
+	return preimage
+}
+
+// RandChainHash generates a random chain hash.
+func RandChainHash(t *rapid.T) chainhash.Hash {
+	var hash [32]byte
+	bytes := rapid.SliceOfN(rapid.Byte(), 32, 32).Draw(t, "chainHash")
+	copy(hash[:], bytes)
+
+	return hash
+}
+
+// RandNodeAlias generates a random node alias.
+func RandNodeAlias(t *rapid.T) NodeAlias {
+	var alias NodeAlias
+	aliasLength := rapid.IntRange(0, 32).Draw(t, "aliasLength")
+
+	aliasBytes := rapid.StringN(
+		0, aliasLength, aliasLength,
+	).Draw(t, "alias")
+
+	copy(alias[:], aliasBytes)
+
+	return alias
+}
+
+// RandNetAddrs generates random network addresses.
+func RandNetAddrs(t *rapid.T) []net.Addr {
+	numAddresses := rapid.IntRange(0, 5).Draw(t, "numAddresses")
+	if numAddresses == 0 {
+		return nil
+	}
+
+	addresses := make([]net.Addr, numAddresses)
+	for i := 0; i < numAddresses; i++ {
+		addressType := rapid.IntRange(0, 1).Draw(
+			t, fmt.Sprintf("addressType-%d", i),
+		)
+
+		switch addressType {
+		// IPv4.
+		case 0:
+			ipBytes := rapid.SliceOfN(rapid.Byte(), 4, 4).Draw(
+				t, fmt.Sprintf("ipv4-%d", i),
+			)
+			port := rapid.IntRange(1, 65535).Draw(
+				t, fmt.Sprintf("port-%d", i),
+			)
+			addresses[i] = &net.TCPAddr{
+				IP:   ipBytes,
+				Port: port,
+			}
+
+		// IPv6.
+		case 1:
+			ipBytes := rapid.SliceOfN(rapid.Byte(), 16, 16).Draw(
+				t, fmt.Sprintf("ipv6-%d", i),
+			)
+			port := rapid.IntRange(1, 65535).Draw(
+				t, fmt.Sprintf("port-%d", i),
+			)
+			addresses[i] = &net.TCPAddr{
+				IP:   ipBytes,
+				Port: port,
+			}
+		}
+	}
+
+	return addresses
+}
+
+// RandCustomRecords generates random custom TLV records.
+func RandCustomRecords(t *rapid.T,
+	ignoreRecords fn.Set[uint64],
+	custom bool) (CustomRecords, fn.Set[uint64]) {
+
+	numRecords := rapid.IntRange(0, 5).Draw(t, "numCustomRecords")
+	customRecords := make(CustomRecords)
+
+	if numRecords == 0 {
+		return nil, nil
+	}
+
+	rangeStart := 0
+	rangeStop := int(CustomTypeStart)
+	if custom {
+		rangeStart = 70_000
+		rangeStop = 100_000
+	}
+
+	ignoreSet := fn.NewSet[uint64]()
+	for i := 0; i < numRecords; i++ {
+		recordType := uint64(
+			rapid.IntRange(rangeStart, rangeStop).
+				Filter(func(i int) bool {
+					return !ignoreRecords.Contains(
+						uint64(i),
+					)
+				}).
+				Draw(
+					t, fmt.Sprintf("recordType-%d", i),
+				),
+		)
+		recordLen := rapid.IntRange(4, 64).Draw(
+			t, fmt.Sprintf("recordLen-%d", i),
+		)
+		record := rapid.SliceOfN(
+			rapid.Byte(), recordLen, recordLen,
+		).Draw(t, fmt.Sprintf("record-%d", i))
+
+		customRecords[recordType] = record
+
+		ignoreSet.Add(recordType)
+	}
+
+	return customRecords, ignoreSet
+}
+
+// RandMusig2Nonce generates a random musig2 nonce.
+func RandMusig2Nonce(t *rapid.T) Musig2Nonce {
+	var nonce Musig2Nonce
+	bytes := rapid.SliceOfN(rapid.Byte(), 32, 32).Draw(t, "nonce")
+	copy(nonce[:], bytes)
+
+	return nonce
+}
+
+// RandExtraOpaqueData generates random extra opaque data.
+func RandExtraOpaqueData(t *rapid.T,
+	ignoreRecords fn.Set[uint64]) ExtraOpaqueData {
+
+	// Make some random records.
+	cRecords, _ := RandCustomRecords(t, ignoreRecords, false)
+	if cRecords == nil {
+		return ExtraOpaqueData{}
+	}
+
+	// Encode those records as opaque data.
+	recordBytes, err := cRecords.Serialize()
+	require.NoError(t, err)
+
+	return ExtraOpaqueData(recordBytes)
+}
+
+// RandOpaqueReason generates a random opaque reason for HTLC failures.
+func RandOpaqueReason(t *rapid.T) OpaqueReason {
+	reasonLen := rapid.IntRange(32, 300).Draw(t, "reasonLen")
+	return rapid.SliceOfN(rapid.Byte(), reasonLen, reasonLen).Draw(
+		t, "opaqueReason",
+	)
+}
+
+// RandFailCode generates a random HTLC failure code.
+func RandFailCode(t *rapid.T) FailCode {
+	// List of known failure codes to choose from Using only the documented
+	// codes.
+	validCodes := []FailCode{
+		CodeInvalidRealm,
+		CodeTemporaryNodeFailure,
+		CodePermanentNodeFailure,
+		CodeRequiredNodeFeatureMissing,
+		CodePermanentChannelFailure,
+		CodeRequiredChannelFeatureMissing,
+		CodeUnknownNextPeer,
+		CodeIncorrectOrUnknownPaymentDetails,
+		CodeIncorrectPaymentAmount,
+		CodeFinalExpiryTooSoon,
+		CodeInvalidOnionVersion,
+		CodeInvalidOnionHmac,
+		CodeInvalidOnionKey,
+		CodeTemporaryChannelFailure,
+		CodeChannelDisabled,
+		CodeExpiryTooSoon,
+		CodeMPPTimeout,
+		CodeInvalidOnionPayload,
+		CodeFeeInsufficient,
+	}
+
+	// Choose a random code from the list.
+	idx := rapid.IntRange(0, len(validCodes)-1).Draw(t, "failCodeIndex")
+
+	return validCodes[idx]
+}
+
+// RandSHA256Hash generates a random SHA256 hash.
+func RandSHA256Hash(t *rapid.T) [sha256.Size]byte {
+	var hash [sha256.Size]byte
+	bytes := rapid.SliceOfN(rapid.Byte(), sha256.Size, sha256.Size).Draw(
+		t, "sha256Hash",
+	)
+	copy(hash[:], bytes)
+
+	return hash
+}
+
+// RandDeliveryAddress generates a random delivery address (script).
+func RandDeliveryAddress(t *rapid.T) DeliveryAddress {
+	addrLen := rapid.IntRange(1, 34).Draw(t, "addrLen")
+
+	return rapid.SliceOfN(rapid.Byte(), addrLen, addrLen).Draw(
+		t, "deliveryAddress",
+	)
+}
+
+// RandChannelType generates a random channel type.
+func RandChannelType(t *rapid.T) *ChannelType {
+	vec := RandFeatureVector(t)
+	chanType := ChannelType(*vec)
+
+	return &chanType
+}
+
+// RandLeaseExpiry generates a random lease expiry.
+func RandLeaseExpiry(t *rapid.T) *LeaseExpiry {
+	exp := LeaseExpiry(
+		uint32(rapid.IntRange(1000, 1000000).Draw(t, "leaseExpiry")),
+	)
+
+	return &exp
+}
+
+// RandOutPoint generates a random transaction outpoint.
+func RandOutPoint(t *rapid.T) wire.OutPoint {
+	// Generate a random transaction ID
+	var txid chainhash.Hash
+	txidBytes := rapid.SliceOfN(rapid.Byte(), 32, 32).Draw(t, "txid")
+	copy(txid[:], txidBytes)
+
+	// Generate a random output index
+	vout := uint32(rapid.IntRange(0, 10).Draw(t, "vout"))
+
+	return wire.OutPoint{
+		Hash:  txid,
+		Index: vout,
+	}
+}

lnwire/update_add_htlc.go

@@ -212,3 +212,14 @@ func (c *UpdateAddHTLC) MsgType() MessageType {
 func (c *UpdateAddHTLC) TargetChanID() ChannelID {
 	return c.ChanID
 }
+
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (c *UpdateAddHTLC) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(c)
+}
+
+// A compile time check to ensure UpdateAddHTLC implements the
+// lnwire.SizeableMessage interface.
+var _ SizeableMessage = (*UpdateAddHTLC)(nil)

lnwire/update_fail_htlc.go

@@ -38,6 +38,10 @@ type UpdateFailHTLC struct {
 // interface.
 var _ Message = (*UpdateFailHTLC)(nil)
 
+// A compile time check to ensure UpdateFailHTLC implements the
+// lnwire.SizeableMessage interface.
+var _ SizeableMessage = (*UpdateFailHTLC)(nil)
+
 // Decode deserializes a serialized UpdateFailHTLC message stored in the passed
 // io.Reader observing the specified protocol version.
 //
@@ -51,8 +55,8 @@ func (c *UpdateFailHTLC) Decode(r io.Reader, pver uint32) error {
 	)
 }
 
-// Encode serializes the target UpdateFailHTLC into the passed io.Writer observing
-// the protocol version specified.
+// Encode serializes the target UpdateFailHTLC into the passed io.Writer
+// observing the protocol version specified.
 //
 // This is part of the lnwire.Message interface.
 func (c *UpdateFailHTLC) Encode(w *bytes.Buffer, pver uint32) error {
@@ -79,6 +83,13 @@ func (c *UpdateFailHTLC) MsgType() MessageType {
 	return MsgUpdateFailHTLC
 }
 
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (c *UpdateFailHTLC) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(c)
+}
+
 // TargetChanID returns the channel id of the link for which this message is
 // intended.
 //

lnwire/update_fail_malformed_htlc.go

@@ -36,6 +36,10 @@ type UpdateFailMalformedHTLC struct {
 // lnwire.Message interface.
 var _ Message = (*UpdateFailMalformedHTLC)(nil)
 
+// A compile time check to ensure UpdateFailMalformedHTLC implements the
+// lnwire.SizeableMessage interface.
+var _ SizeableMessage = (*UpdateFailMalformedHTLC)(nil)
+
 // Decode deserializes a serialized UpdateFailMalformedHTLC message stored in the passed
 // io.Reader observing the specified protocol version.
 //
@@ -84,6 +88,13 @@ func (c *UpdateFailMalformedHTLC) MsgType() MessageType {
 	return MsgUpdateFailMalformedHTLC
 }
 
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (c *UpdateFailMalformedHTLC) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(c)
+}
+
 // TargetChanID returns the channel id of the link for which this message is
 // intended.
 //

lnwire/update_fee.go

@@ -36,6 +36,10 @@ func NewUpdateFee(chanID ChannelID, feePerKw uint32) *UpdateFee {
 // interface.
 var _ Message = (*UpdateFee)(nil)
 
+// A compile time check to ensure UpdateFee implements the
+// lnwire.SizeableMessage interface.
+var _ SizeableMessage = (*UpdateFee)(nil)
+
 // Decode deserializes a serialized UpdateFee message stored in the passed
 // io.Reader observing the specified protocol version.
 //
@@ -72,6 +76,13 @@ func (c *UpdateFee) MsgType() MessageType {
 	return MsgUpdateFee
 }
 
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (c *UpdateFee) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(c)
+}
+
 // TargetChanID returns the channel id of the link for which this message is
 // intended.
 //

lnwire/update_fulfill_htlc.go

@@ -44,12 +44,16 @@ func NewUpdateFulfillHTLC(chanID ChannelID, id uint64,
 	}
 }
 
-// A compile time check to ensure UpdateFulfillHTLC implements the lnwire.Message
-// interface.
+// A compile time check to ensure UpdateFulfillHTLC implements the
+// lnwire.Message interface.
 var _ Message = (*UpdateFulfillHTLC)(nil)
 
-// Decode deserializes a serialized UpdateFulfillHTLC message stored in the passed
-// io.Reader observing the specified protocol version.
+// A compile time check to ensure UpdateFulfillHTLC implements the
+// lnwire.SizeableMessage interface.
+var _ SizeableMessage = (*UpdateFulfillHTLC)(nil)
+
+// Decode deserializes a serialized UpdateFulfillHTLC message stored in the
+// passed io.Reader observing the specified protocol version.
 //
 // This is part of the lnwire.Message interface.
 func (c *UpdateFulfillHTLC) Decode(r io.Reader, pver uint32) error {
@@ -115,6 +119,13 @@ func (c *UpdateFulfillHTLC) MsgType() MessageType {
 	return MsgUpdateFulfillHTLC
 }
 
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (c *UpdateFulfillHTLC) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(c)
+}
+
 // TargetChanID returns the channel id of the link for which this message is
 // intended.
 //

lnwire/warning.go

@@ -29,6 +29,10 @@ type Warning struct {
 // interface.
 var _ Message = (*Warning)(nil)
 
+// A compile time check to ensure Warning implements the lnwire.SizeableMessage
+// interface.
+var _ SizeableMessage = (*Warning)(nil)
+
 // NewWarning creates a new Warning message.
 func NewWarning() *Warning {
 	return &Warning{}
@@ -74,3 +78,10 @@ func (c *Warning) Encode(w *bytes.Buffer, _ uint32) error {
 func (c *Warning) MsgType() MessageType {
 	return MsgWarning
 }
+
+// SerializedSize returns the serialized size of the message in bytes.
+//
+// This is part of the lnwire.SizeableMessage interface.
+func (c *Warning) SerializedSize() (uint32, error) {
+	return MessageSerializedSize(c)
+}