5679dde1bc
Add more fields to channel acceptor response so that users can have more fine grained control over their incoming channels. With our chained acceptor, it is possible that we get inconsistent responses from multiple chained acceptors. We create a conjugate repsponse from all the set fields in our various responses, but fail if we get different, non- zero responses from our various acceptors. Separate merge functions are used per type so that we avoid unexpected outcomes comparing interfaces (panic on comparing types that aren't comparable), with casting used where applicable to avoid code duplication.
116 lines
3.6 KiB
Go
116 lines
3.6 KiB
Go
package chanacceptor
|
|
|
|
import (
|
|
"errors"
|
|
|
|
"github.com/btcsuite/btcd/btcec"
|
|
"github.com/btcsuite/btcutil"
|
|
"github.com/lightningnetwork/lnd/lnwire"
|
|
)
|
|
|
|
var (
|
|
// errChannelRejected is returned when the rpc channel acceptor rejects
|
|
// a channel due to acceptor timeout, shutdown, or because no custom
|
|
// error value is available when the channel was rejected.
|
|
errChannelRejected = errors.New("channel rejected")
|
|
)
|
|
|
|
// ChannelAcceptRequest is a struct containing the requesting node's public key
|
|
// along with the lnwire.OpenChannel message that they sent when requesting an
|
|
// inbound channel. This information is provided to each acceptor so that they
|
|
// can each leverage their own decision-making with this information.
|
|
type ChannelAcceptRequest struct {
|
|
// Node is the public key of the node requesting to open a channel.
|
|
Node *btcec.PublicKey
|
|
|
|
// OpenChanMsg is the actual OpenChannel protocol message that the peer
|
|
// sent to us.
|
|
OpenChanMsg *lnwire.OpenChannel
|
|
}
|
|
|
|
// ChannelAcceptResponse is a struct containing the response to a request to
|
|
// open an inbound channel. Note that fields added to this struct must be added
|
|
// to the mergeResponse function to allow combining of responses from different
|
|
// acceptors.
|
|
type ChannelAcceptResponse struct {
|
|
// ChanAcceptError the error returned by the channel acceptor. If the
|
|
// channel was accepted, this value will be nil.
|
|
ChanAcceptError
|
|
|
|
// UpfrontShutdown is the address that we will set as our upfront
|
|
// shutdown address.
|
|
UpfrontShutdown lnwire.DeliveryAddress
|
|
|
|
// CSVDelay is the csv delay we require for the remote peer.
|
|
CSVDelay uint16
|
|
|
|
// Reserve is the amount that require the remote peer hold in reserve
|
|
// on the channel.
|
|
Reserve btcutil.Amount
|
|
|
|
// InFlightTotal is the maximum amount that we allow the remote peer to
|
|
// hold in outstanding htlcs.
|
|
InFlightTotal lnwire.MilliSatoshi
|
|
|
|
// HtlcLimit is the maximum number of htlcs that we allow the remote
|
|
// peer to offer us.
|
|
HtlcLimit uint16
|
|
|
|
// MinHtlcIn is the minimum incoming htlc value allowed on the channel.
|
|
MinHtlcIn lnwire.MilliSatoshi
|
|
|
|
// MinAcceptDepth is the minimum depth that the initiator of the
|
|
// channel should wait before considering the channel open.
|
|
MinAcceptDepth uint16
|
|
}
|
|
|
|
// NewChannelAcceptResponse is a constructor for a channel accept response,
|
|
// which creates a response with an appropriately wrapped error (in the case of
|
|
// a rejection) so that the error will be whitelisted and delivered to the
|
|
// initiating peer. Accepted channels simply return a response containing a nil
|
|
// error.
|
|
func NewChannelAcceptResponse(accept bool, acceptErr error,
|
|
upfrontShutdown lnwire.DeliveryAddress, csvDelay, htlcLimit,
|
|
minDepth uint16, reserve btcutil.Amount, inFlight,
|
|
minHtlcIn lnwire.MilliSatoshi) *ChannelAcceptResponse {
|
|
|
|
resp := &ChannelAcceptResponse{
|
|
UpfrontShutdown: upfrontShutdown,
|
|
CSVDelay: csvDelay,
|
|
Reserve: reserve,
|
|
InFlightTotal: inFlight,
|
|
HtlcLimit: htlcLimit,
|
|
MinHtlcIn: minHtlcIn,
|
|
MinAcceptDepth: minDepth,
|
|
}
|
|
|
|
// If we want to accept the channel, we return a response with a nil
|
|
// error.
|
|
if accept {
|
|
return resp
|
|
}
|
|
|
|
// Use a generic error when no custom error is provided.
|
|
if acceptErr == nil {
|
|
acceptErr = errChannelRejected
|
|
}
|
|
|
|
resp.ChanAcceptError = ChanAcceptError{
|
|
error: acceptErr,
|
|
}
|
|
|
|
return resp
|
|
}
|
|
|
|
// RejectChannel returns a boolean that indicates whether we should reject the
|
|
// channel.
|
|
func (c *ChannelAcceptResponse) RejectChannel() bool {
|
|
return c.error != nil
|
|
}
|
|
|
|
// ChannelAcceptor is an interface that represents a predicate on the data
|
|
// contained in ChannelAcceptRequest.
|
|
type ChannelAcceptor interface {
|
|
Accept(req *ChannelAcceptRequest) *ChannelAcceptResponse
|
|
}
|