lnd/lnwire/funding_locked.go

111 lines
3.2 KiB
Go
Raw Normal View History

package lnwire
import (
"fmt"
"io"
"github.com/roasbeef/btcd/btcec"
"github.com/roasbeef/btcd/wire"
)
// FundingLocked is the message that both parties to a new channel creation
// send once they have observed the funding transaction being confirmed on
// the blockchain. FundingLocked contains the signatures necessary for the
// channel participants to advertise the existence of the channel to the
// rest of the network.
type FundingLocked struct {
// ChannelOutpoint is the outpoint of the channel's funding
// transaction. This can be used to query for the channel in the
// database.
ChannelOutpoint wire.OutPoint
// ChannelId serves to uniquely identify the channel created by the
// current channel funding workflow.
ChannelID ChannelID
// NextPerCommitmentPoint is the secret that can be used to revoke
// the next commitment transaction for the channel.
NextPerCommitmentPoint *btcec.PublicKey
}
// NewFundingLocked creates a new FundingLocked message, populating it with
// the necessary IDs and revocation secret..
func NewFundingLocked(op wire.OutPoint, cid ChannelID,
npcp *btcec.PublicKey) *FundingLocked {
return &FundingLocked{
ChannelOutpoint: op,
ChannelID: cid,
NextPerCommitmentPoint: npcp,
}
}
// A compile time check to ensure FundingLocked implements the
// lnwire.Message interface.
var _ Message = (*FundingLocked)(nil)
// Decode deserializes the serialized FundingLocked message stored in the passed
// io.Reader into the target FundingLocked using the deserialization
// rules defined by the passed protocol version.
//
// This is part of the lnwire.Message interface.
func (c *FundingLocked) Decode(r io.Reader, pver uint32) error {
return readElements(r,
&c.ChannelOutpoint,
&c.ChannelID,
&c.NextPerCommitmentPoint)
}
// Encode serializes the target FundingLocked 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 *FundingLocked) Encode(w io.Writer, pver uint32) error {
return writeElements(w,
c.ChannelOutpoint,
c.ChannelID,
c.NextPerCommitmentPoint)
}
// Command returns the uint32 code which uniquely identifies this message as a
// FundingLocked message on the wire.
//
// This is part of the lnwire.Message interface.
func (c *FundingLocked) Command() uint32 {
return CmdFundingLocked
}
// MaxPayloadLength returns the maximum allowed payload length for a
// FundingLocked message. This is calculated by summing the max length of all
// the fields within a FundingLocked message.
//
// This is part of the lnwire.Message interface.
func (c *FundingLocked) MaxPayloadLength(uint32) uint32 {
var length uint32
// ChannelOutpoint - 36 bytes
length += 36
// ChannelID - 8 bytes
length += 8
// NextPerCommitmentPoint - 33 bytes
length += 33
return length
}
// Validate examines each populated field within the FundingLocked message for
// field sanity. For example, signature fields MUST NOT be nil.
//
// This is part of the lnwire.Message interface.
func (c *FundingLocked) Validate() error {
if c.NextPerCommitmentPoint == nil {
return fmt.Errorf("the next per commitment point must be " +
"non-nil.")
}
// We're good!
return nil
}