funding+lnwire: rename and fix make lint

Fix linter and rename `funding_locked.go` to `channel_ready.go`

lnwire/channel_ready.go

@@ -0,0 +1,115 @@
+package lnwire
+
+import (
+	"bytes"
+	"io"
+
+	"github.com/btcsuite/btcd/btcec/v2"
+	"github.com/lightningnetwork/lnd/tlv"
+)
+
+// ChannelReady is the message that both parties to a new channel creation
+// send once they have observed the funding transaction being confirmed on the
+// blockchain. ChannelReady contains the signatures necessary for the channel
+// participants to advertise the existence of the channel to the rest of the
+// network.
+type ChannelReady struct {
+	// ChanID is the outpoint of the channel's funding transaction. This
+	// can be used to query for the channel in the database.
+	ChanID ChannelID
+
+	// NextPerCommitmentPoint is the secret that can be used to revoke the
+	// next commitment transaction for the channel.
+	NextPerCommitmentPoint *btcec.PublicKey
+
+	// AliasScid is an alias ShortChannelID used to refer to the underlying
+	// channel. It can be used instead of the confirmed on-chain
+	// ShortChannelID for forwarding.
+	AliasScid *ShortChannelID
+
+	// ExtraData is the set of data that was appended to this message to
+	// fill out the full maximum transport message size. These fields can
+	// be used to specify optional data such as custom TLV fields.
+	ExtraData ExtraOpaqueData
+}
+
+// NewChannelReady creates a new ChannelReady message, populating it with the
+// necessary IDs and revocation secret.
+func NewChannelReady(cid ChannelID, npcp *btcec.PublicKey) *ChannelReady {
+	return &ChannelReady{
+		ChanID:                 cid,
+		NextPerCommitmentPoint: npcp,
+		ExtraData:              make([]byte, 0),
+	}
+}
+
+// A compile time check to ensure ChannelReady implements the lnwire.Message
+// interface.
+var _ Message = (*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.
+//
+// This is part of the lnwire.Message interface.
+func (c *ChannelReady) Decode(r io.Reader, pver uint32) error {
+	// Read all the mandatory fields in the message.
+	err := ReadElements(r,
+		&c.ChanID,
+		&c.NextPerCommitmentPoint,
+		&c.ExtraData,
+	)
+	if err != nil {
+		return err
+	}
+
+	// Next we'll parse out the set of known records. For now, this is just
+	// the AliasScidRecordType.
+	var aliasScid ShortChannelID
+	typeMap, err := c.ExtraData.ExtractRecords(&aliasScid)
+	if err != nil {
+		return err
+	}
+
+	// We'll only set AliasScid if the corresponding TLV type was included
+	// in the stream.
+	if val, ok := typeMap[AliasScidRecordType]; ok && val == nil {
+		c.AliasScid = &aliasScid
+	}
+
+	return nil
+}
+
+// Encode serializes the target ChannelReady message into the passed io.Writer
+// implementation. Serialization will observe the rules defined by the passed
+// protocol version.
+//
+// This is part of the lnwire.Message interface.
+func (c *ChannelReady) Encode(w *bytes.Buffer, pver uint32) error {
+	if err := WriteChannelID(w, c.ChanID); err != nil {
+		return err
+	}
+
+	if err := WritePublicKey(w, c.NextPerCommitmentPoint); err != nil {
+		return err
+	}
+
+	// We'll only encode the AliasScid in a TLV segment if it exists.
+	if c.AliasScid != nil {
+		recordProducers := []tlv.RecordProducer{c.AliasScid}
+		err := EncodeMessageExtraData(&c.ExtraData, recordProducers...)
+		if err != nil {
+			return err
+		}
+	}
+
+	return WriteBytes(w, c.ExtraData)
+}
+
+// MsgType returns the uint32 code which uniquely identifies this message as a
+// ChannelReady message on the wire.
+//
+// This is part of the lnwire.Message interface.
+func (c *ChannelReady) MsgType() MessageType {
+	return MsgChannelReady
+}