111 lines
3.2 KiB
Go
111 lines
3.2 KiB
Go
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
|
|
}
|