203 lines
7.0 KiB
Go
203 lines
7.0 KiB
Go
package lnwire
|
|
|
|
import (
|
|
"io"
|
|
|
|
"github.com/btcsuite/btcd/btcec"
|
|
"github.com/btcsuite/btcd/chaincfg/chainhash"
|
|
"github.com/btcsuite/btcutil"
|
|
)
|
|
|
|
// FundingFlag represents the possible bit mask values for the ChannelFlags
|
|
// field within the OpenChannel struct.
|
|
type FundingFlag uint8
|
|
|
|
const (
|
|
// FFAnnounceChannel is a FundingFlag that when set, indicates the
|
|
// initiator of a funding flow wishes to announce the channel to the
|
|
// greater network.
|
|
FFAnnounceChannel FundingFlag = 1 << iota
|
|
)
|
|
|
|
// OpenChannel is the message Alice sends to Bob if we should like to create a
|
|
// channel with Bob where she's the sole provider of funds to the channel.
|
|
// Single funder channels simplify the initial funding workflow, are supported
|
|
// by nodes backed by SPV Bitcoin clients, and have a simpler security models
|
|
// than dual funded channels.
|
|
type OpenChannel struct {
|
|
// ChainHash is the target chain that the initiator wishes to open a
|
|
// channel within.
|
|
ChainHash chainhash.Hash
|
|
|
|
// PendingChannelID serves to uniquely identify the future channel
|
|
// created by the initiated single funder workflow.
|
|
PendingChannelID [32]byte
|
|
|
|
// FundingAmount is the amount of satoshis that the initiator of the
|
|
// channel wishes to use as the total capacity of the channel. The
|
|
// initial balance of the funding will be this value minus the push
|
|
// amount (if set).
|
|
FundingAmount btcutil.Amount
|
|
|
|
// PushAmount is the value that the initiating party wishes to "push"
|
|
// to the responding as part of the first commitment state. If the
|
|
// responder accepts, then this will be their initial balance.
|
|
PushAmount MilliSatoshi
|
|
|
|
// DustLimit is the specific dust limit the sender of this message
|
|
// would like enforced on their version of the commitment transaction.
|
|
// Any output below this value will be "trimmed" from the commitment
|
|
// transaction, with the amount of the HTLC going to dust.
|
|
DustLimit btcutil.Amount
|
|
|
|
// MaxValueInFlight represents the maximum amount of coins that can be
|
|
// pending within the channel at any given time. If the amount of funds
|
|
// in limbo exceeds this amount, then the channel will be failed.
|
|
MaxValueInFlight MilliSatoshi
|
|
|
|
// ChannelReserve is the amount of BTC that the receiving party MUST
|
|
// maintain a balance above at all times. This is a safety mechanism to
|
|
// ensure that both sides always have skin in the game during the
|
|
// channel's lifetime.
|
|
ChannelReserve btcutil.Amount
|
|
|
|
// HtlcMinimum is the smallest HTLC that the sender of this message
|
|
// will accept.
|
|
HtlcMinimum MilliSatoshi
|
|
|
|
// FeePerKiloWeight is the initial fee rate that the initiator suggests
|
|
// for both commitment transaction. This value is expressed in sat per
|
|
// kilo-weight.
|
|
//
|
|
// TODO(halseth): make SatPerKWeight when fee estimation is in own
|
|
// package. Currently this will cause an import cycle.
|
|
FeePerKiloWeight uint32
|
|
|
|
// CsvDelay is the number of blocks to use for the relative time lock
|
|
// in the pay-to-self output of both commitment transactions.
|
|
CsvDelay uint16
|
|
|
|
// MaxAcceptedHTLCs is the total number of incoming HTLC's that the
|
|
// sender of this channel will accept.
|
|
MaxAcceptedHTLCs uint16
|
|
|
|
// FundingKey is the key that should be used on behalf of the sender
|
|
// within the 2-of-2 multi-sig output that it contained within the
|
|
// funding transaction.
|
|
FundingKey *btcec.PublicKey
|
|
|
|
// RevocationPoint is the base revocation point for the sending party.
|
|
// Any commitment transaction belonging to the receiver of this message
|
|
// should use this key and their per-commitment point to derive the
|
|
// revocation key for the commitment transaction.
|
|
RevocationPoint *btcec.PublicKey
|
|
|
|
// PaymentPoint is the base payment point for the sending party. This
|
|
// key should be combined with the per commitment point for a
|
|
// particular commitment state in order to create the key that should
|
|
// be used in any output that pays directly to the sending party, and
|
|
// also within the HTLC covenant transactions.
|
|
PaymentPoint *btcec.PublicKey
|
|
|
|
// DelayedPaymentPoint is the delay point for the sending party. This
|
|
// key should be combined with the per commitment point to derive the
|
|
// keys that are used in outputs of the sender's commitment transaction
|
|
// where they claim funds.
|
|
DelayedPaymentPoint *btcec.PublicKey
|
|
|
|
// HtlcPoint is the base point used to derive the set of keys for this
|
|
// party that will be used within the HTLC public key scripts. This
|
|
// value is combined with the receiver's revocation base point in order
|
|
// to derive the keys that are used within HTLC scripts.
|
|
HtlcPoint *btcec.PublicKey
|
|
|
|
// FirstCommitmentPoint is the first commitment point for the sending
|
|
// party. This value should be combined with the receiver's revocation
|
|
// base point in order to derive the revocation keys that are placed
|
|
// within the commitment transaction of the sender.
|
|
FirstCommitmentPoint *btcec.PublicKey
|
|
|
|
// ChannelFlags is a bit-field which allows the initiator of the
|
|
// channel to specify further behavior surrounding the channel.
|
|
// Currently, the least significant bit of this bit field indicates the
|
|
// initiator of the channel wishes to advertise this channel publicly.
|
|
ChannelFlags FundingFlag
|
|
}
|
|
|
|
// A compile time check to ensure OpenChannel implements the lnwire.Message
|
|
// interface.
|
|
var _ Message = (*OpenChannel)(nil)
|
|
|
|
// Encode serializes the target OpenChannel 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 (o *OpenChannel) Encode(w io.Writer, pver uint32) error {
|
|
return writeElements(w,
|
|
o.ChainHash[:],
|
|
o.PendingChannelID[:],
|
|
o.FundingAmount,
|
|
o.PushAmount,
|
|
o.DustLimit,
|
|
o.MaxValueInFlight,
|
|
o.ChannelReserve,
|
|
o.HtlcMinimum,
|
|
o.FeePerKiloWeight,
|
|
o.CsvDelay,
|
|
o.MaxAcceptedHTLCs,
|
|
o.FundingKey,
|
|
o.RevocationPoint,
|
|
o.PaymentPoint,
|
|
o.DelayedPaymentPoint,
|
|
o.HtlcPoint,
|
|
o.FirstCommitmentPoint,
|
|
o.ChannelFlags,
|
|
)
|
|
}
|
|
|
|
// Decode deserializes the serialized OpenChannel stored in the passed
|
|
// io.Reader into the target OpenChannel using the deserialization rules
|
|
// defined by the passed protocol version.
|
|
//
|
|
// This is part of the lnwire.Message interface.
|
|
func (o *OpenChannel) Decode(r io.Reader, pver uint32) error {
|
|
return readElements(r,
|
|
o.ChainHash[:],
|
|
o.PendingChannelID[:],
|
|
&o.FundingAmount,
|
|
&o.PushAmount,
|
|
&o.DustLimit,
|
|
&o.MaxValueInFlight,
|
|
&o.ChannelReserve,
|
|
&o.HtlcMinimum,
|
|
&o.FeePerKiloWeight,
|
|
&o.CsvDelay,
|
|
&o.MaxAcceptedHTLCs,
|
|
&o.FundingKey,
|
|
&o.RevocationPoint,
|
|
&o.PaymentPoint,
|
|
&o.DelayedPaymentPoint,
|
|
&o.HtlcPoint,
|
|
&o.FirstCommitmentPoint,
|
|
&o.ChannelFlags,
|
|
)
|
|
}
|
|
|
|
// MsgType returns the MessageType code which uniquely identifies this message
|
|
// as an OpenChannel on the wire.
|
|
//
|
|
// This is part of the lnwire.Message interface.
|
|
func (o *OpenChannel) MsgType() MessageType {
|
|
return MsgOpenChannel
|
|
}
|
|
|
|
// MaxPayloadLength returns the maximum allowed payload length for a
|
|
// OpenChannel message.
|
|
//
|
|
// This is part of the lnwire.Message interface.
|
|
func (o *OpenChannel) MaxPayloadLength(uint32) uint32 {
|
|
// (32 * 2) + (8 * 6) + (4 * 1) + (2 * 2) + (33 * 6) + 1
|
|
return 319
|
|
}
|