lnd+funding: move Manager to funding, change references
This commit is contained in:
parent
e7e872f19a
commit
dcdf36f410
3528
funding/manager.go
3528
funding/manager.go
@ -1,12 +1,38 @@
|
|||||||
package funding
|
package funding
|
||||||
|
|
||||||
import (
|
import (
|
||||||
|
"bytes"
|
||||||
"encoding/binary"
|
"encoding/binary"
|
||||||
|
"fmt"
|
||||||
"io"
|
"io"
|
||||||
|
"sync"
|
||||||
|
"time"
|
||||||
|
|
||||||
|
"github.com/btcsuite/btcd/btcec"
|
||||||
|
"github.com/btcsuite/btcd/chaincfg/chainhash"
|
||||||
|
"github.com/btcsuite/btcd/txscript"
|
||||||
"github.com/btcsuite/btcd/wire"
|
"github.com/btcsuite/btcd/wire"
|
||||||
"github.com/btcsuite/btcutil"
|
"github.com/btcsuite/btcutil"
|
||||||
|
"github.com/davecgh/go-spew/spew"
|
||||||
|
"github.com/go-errors/errors"
|
||||||
|
"github.com/lightningnetwork/lnd/chainntnfs"
|
||||||
"github.com/lightningnetwork/lnd/chainreg"
|
"github.com/lightningnetwork/lnd/chainreg"
|
||||||
|
"github.com/lightningnetwork/lnd/chanacceptor"
|
||||||
|
"github.com/lightningnetwork/lnd/channeldb"
|
||||||
|
"github.com/lightningnetwork/lnd/channeldb/kvdb"
|
||||||
|
"github.com/lightningnetwork/lnd/discovery"
|
||||||
|
"github.com/lightningnetwork/lnd/htlcswitch"
|
||||||
|
"github.com/lightningnetwork/lnd/input"
|
||||||
|
"github.com/lightningnetwork/lnd/keychain"
|
||||||
|
"github.com/lightningnetwork/lnd/labels"
|
||||||
|
"github.com/lightningnetwork/lnd/lnpeer"
|
||||||
|
"github.com/lightningnetwork/lnd/lnrpc"
|
||||||
|
"github.com/lightningnetwork/lnd/lnwallet"
|
||||||
|
"github.com/lightningnetwork/lnd/lnwallet/chainfee"
|
||||||
|
"github.com/lightningnetwork/lnd/lnwallet/chanfunding"
|
||||||
|
"github.com/lightningnetwork/lnd/lnwire"
|
||||||
|
"github.com/lightningnetwork/lnd/routing"
|
||||||
|
"golang.org/x/crypto/salsa20"
|
||||||
)
|
)
|
||||||
|
|
||||||
var (
|
var (
|
||||||
@ -66,4 +92,3506 @@ const (
|
|||||||
// currently accepted on the Litecoin chain within the Lightning
|
// currently accepted on the Litecoin chain within the Lightning
|
||||||
// Protocol.
|
// Protocol.
|
||||||
MaxLtcFundingAmount = MaxBtcFundingAmount * chainreg.BtcToLtcConversionRate
|
MaxLtcFundingAmount = MaxBtcFundingAmount * chainreg.BtcToLtcConversionRate
|
||||||
|
|
||||||
|
// TODO(roasbeef): tune
|
||||||
|
msgBufferSize = 50
|
||||||
|
|
||||||
|
// maxWaitNumBlocksFundingConf is the maximum number of blocks to wait
|
||||||
|
// for the funding transaction to be confirmed before forgetting
|
||||||
|
// channels that aren't initiated by us. 2016 blocks is ~2 weeks.
|
||||||
|
maxWaitNumBlocksFundingConf = 2016
|
||||||
)
|
)
|
||||||
|
|
||||||
|
var (
|
||||||
|
// ErrFundingManagerShuttingDown is an error returned when attempting to
|
||||||
|
// process a funding request/message but the funding manager has already
|
||||||
|
// been signaled to shut down.
|
||||||
|
ErrFundingManagerShuttingDown = errors.New("funding manager shutting " +
|
||||||
|
"down")
|
||||||
|
|
||||||
|
// ErrConfirmationTimeout is an error returned when we as a responder
|
||||||
|
// are waiting for a funding transaction to confirm, but too many
|
||||||
|
// blocks pass without confirmation.
|
||||||
|
ErrConfirmationTimeout = errors.New("timeout waiting for funding " +
|
||||||
|
"confirmation")
|
||||||
|
|
||||||
|
// errUpfrontShutdownScriptNotSupported is returned if an upfront shutdown
|
||||||
|
// script is set for a peer that does not support the feature bit.
|
||||||
|
errUpfrontShutdownScriptNotSupported = errors.New("peer does not support" +
|
||||||
|
"option upfront shutdown script")
|
||||||
|
|
||||||
|
zeroID [32]byte
|
||||||
|
)
|
||||||
|
|
||||||
|
// reservationWithCtx encapsulates a pending channel reservation. This wrapper
|
||||||
|
// struct is used internally within the funding manager to track and progress
|
||||||
|
// the funding workflow initiated by incoming/outgoing methods from the target
|
||||||
|
// peer. Additionally, this struct houses a response and error channel which is
|
||||||
|
// used to respond to the caller in the case a channel workflow is initiated
|
||||||
|
// via a local signal such as RPC.
|
||||||
|
//
|
||||||
|
// TODO(roasbeef): actually use the context package
|
||||||
|
// * deadlines, etc.
|
||||||
|
type reservationWithCtx struct {
|
||||||
|
reservation *lnwallet.ChannelReservation
|
||||||
|
peer lnpeer.Peer
|
||||||
|
|
||||||
|
chanAmt btcutil.Amount
|
||||||
|
|
||||||
|
// Constraints we require for the remote.
|
||||||
|
remoteCsvDelay uint16
|
||||||
|
remoteMinHtlc lnwire.MilliSatoshi
|
||||||
|
remoteMaxValue lnwire.MilliSatoshi
|
||||||
|
remoteMaxHtlcs uint16
|
||||||
|
|
||||||
|
// maxLocalCsv is the maximum csv we will accept from the remote.
|
||||||
|
maxLocalCsv uint16
|
||||||
|
|
||||||
|
updateMtx sync.RWMutex
|
||||||
|
lastUpdated time.Time
|
||||||
|
|
||||||
|
updates chan *lnrpc.OpenStatusUpdate
|
||||||
|
err chan error
|
||||||
|
}
|
||||||
|
|
||||||
|
// isLocked checks the reservation's timestamp to determine whether it is locked.
|
||||||
|
func (r *reservationWithCtx) isLocked() bool {
|
||||||
|
r.updateMtx.RLock()
|
||||||
|
defer r.updateMtx.RUnlock()
|
||||||
|
|
||||||
|
// The time zero value represents a locked reservation.
|
||||||
|
return r.lastUpdated.IsZero()
|
||||||
|
}
|
||||||
|
|
||||||
|
// updateTimestamp updates the reservation's timestamp with the current time.
|
||||||
|
func (r *reservationWithCtx) updateTimestamp() {
|
||||||
|
r.updateMtx.Lock()
|
||||||
|
defer r.updateMtx.Unlock()
|
||||||
|
|
||||||
|
r.lastUpdated = time.Now()
|
||||||
|
}
|
||||||
|
|
||||||
|
// InitFundingMsg is sent by an outside subsystem to the funding manager in
|
||||||
|
// order to kick off a funding workflow with a specified target peer. The
|
||||||
|
// original request which defines the parameters of the funding workflow are
|
||||||
|
// embedded within this message giving the funding manager full context w.r.t
|
||||||
|
// the workflow.
|
||||||
|
type InitFundingMsg struct {
|
||||||
|
// Peer is the peer that we want to open a channel to.
|
||||||
|
Peer lnpeer.Peer
|
||||||
|
|
||||||
|
// TargetPubkey is the public key of the peer.
|
||||||
|
TargetPubkey *btcec.PublicKey
|
||||||
|
|
||||||
|
// ChainHash is the target genesis hash for this channel.
|
||||||
|
ChainHash chainhash.Hash
|
||||||
|
|
||||||
|
// SubtractFees set to true means that fees will be subtracted
|
||||||
|
// from the LocalFundingAmt.
|
||||||
|
SubtractFees bool
|
||||||
|
|
||||||
|
// LocalFundingAmt is the size of the channel.
|
||||||
|
LocalFundingAmt btcutil.Amount
|
||||||
|
|
||||||
|
// PushAmt is the amount pushed to the counterparty.
|
||||||
|
PushAmt lnwire.MilliSatoshi
|
||||||
|
|
||||||
|
// FundingFeePerKw is the fee for the funding transaction.
|
||||||
|
FundingFeePerKw chainfee.SatPerKWeight
|
||||||
|
|
||||||
|
// Private determines whether or not this channel will be private.
|
||||||
|
Private bool
|
||||||
|
|
||||||
|
// MinHtlcIn is the minimum incoming HTLC that we accept.
|
||||||
|
MinHtlcIn lnwire.MilliSatoshi
|
||||||
|
|
||||||
|
// RemoteCsvDelay is the CSV delay we require for the remote peer.
|
||||||
|
RemoteCsvDelay uint16
|
||||||
|
|
||||||
|
// MinConfs indicates the minimum number of confirmations that each
|
||||||
|
// output selected to fund the channel should satisfy.
|
||||||
|
MinConfs int32
|
||||||
|
|
||||||
|
// ShutdownScript is an optional upfront shutdown script for the
|
||||||
|
// channel. This value is optional, so may be nil.
|
||||||
|
ShutdownScript lnwire.DeliveryAddress
|
||||||
|
|
||||||
|
// MaxValueInFlight is the maximum amount of coins in MilliSatoshi
|
||||||
|
// that can be pending within the channel. It only applies to the
|
||||||
|
// remote party.
|
||||||
|
MaxValueInFlight lnwire.MilliSatoshi
|
||||||
|
|
||||||
|
// MaxHtlcs is the maximum number of HTLCs that the remote peer
|
||||||
|
// can offer us.
|
||||||
|
MaxHtlcs uint16
|
||||||
|
|
||||||
|
// MaxLocalCsv is the maximum local csv delay we will accept from our
|
||||||
|
// peer.
|
||||||
|
MaxLocalCsv uint16
|
||||||
|
|
||||||
|
// ChanFunder is an optional channel funder that allows the caller to
|
||||||
|
// control exactly how the channel funding is carried out. If not
|
||||||
|
// specified, then the default chanfunding.WalletAssembler will be
|
||||||
|
// used.
|
||||||
|
ChanFunder chanfunding.Assembler
|
||||||
|
|
||||||
|
// PendingChanID is not all zeroes (the default value), then this will
|
||||||
|
// be the pending channel ID used for the funding flow within the wire
|
||||||
|
// protocol.
|
||||||
|
PendingChanID [32]byte
|
||||||
|
|
||||||
|
// Updates is a channel which updates to the opening status of the channel
|
||||||
|
// are sent on.
|
||||||
|
Updates chan *lnrpc.OpenStatusUpdate
|
||||||
|
|
||||||
|
// Err is a channel which errors encountered during the funding flow are
|
||||||
|
// sent on.
|
||||||
|
Err chan error
|
||||||
|
}
|
||||||
|
|
||||||
|
// fundingMsg is sent by the ProcessFundingMsg function and packages a
|
||||||
|
// funding-specific lnwire.Message along with the lnpeer.Peer that sent it.
|
||||||
|
type fundingMsg struct {
|
||||||
|
msg lnwire.Message
|
||||||
|
peer lnpeer.Peer
|
||||||
|
}
|
||||||
|
|
||||||
|
// pendingChannels is a map instantiated per-peer which tracks all active
|
||||||
|
// pending single funded channels indexed by their pending channel identifier,
|
||||||
|
// which is a set of 32-bytes generated via a CSPRNG.
|
||||||
|
type pendingChannels map[[32]byte]*reservationWithCtx
|
||||||
|
|
||||||
|
// serializedPubKey is used within the FundingManager's activeReservations list
|
||||||
|
// to identify the nodes with which the FundingManager is actively working to
|
||||||
|
// initiate new channels.
|
||||||
|
type serializedPubKey [33]byte
|
||||||
|
|
||||||
|
// newSerializedKey creates a new serialized public key from an instance of a
|
||||||
|
// live pubkey object.
|
||||||
|
func newSerializedKey(pubKey *btcec.PublicKey) serializedPubKey {
|
||||||
|
var s serializedPubKey
|
||||||
|
copy(s[:], pubKey.SerializeCompressed())
|
||||||
|
return s
|
||||||
|
}
|
||||||
|
|
||||||
|
// Config defines the configuration for the FundingManager. All elements
|
||||||
|
// within the configuration MUST be non-nil for the FundingManager to carry out
|
||||||
|
// its duties.
|
||||||
|
type Config struct {
|
||||||
|
// NoWumboChans indicates if we're to reject all incoming wumbo channel
|
||||||
|
// requests, and also reject all outgoing wumbo channel requests.
|
||||||
|
NoWumboChans bool
|
||||||
|
|
||||||
|
// IDKey is the PublicKey that is used to identify this node within the
|
||||||
|
// Lightning Network.
|
||||||
|
IDKey *btcec.PublicKey
|
||||||
|
|
||||||
|
// Wallet handles the parts of the funding process that involves moving
|
||||||
|
// funds from on-chain transaction outputs into Lightning channels.
|
||||||
|
Wallet *lnwallet.LightningWallet
|
||||||
|
|
||||||
|
// PublishTransaction facilitates the process of broadcasting a
|
||||||
|
// transaction to the network.
|
||||||
|
PublishTransaction func(*wire.MsgTx, string) error
|
||||||
|
|
||||||
|
// UpdateLabel updates the label that a transaction has in our wallet,
|
||||||
|
// overwriting any existing labels.
|
||||||
|
UpdateLabel func(chainhash.Hash, string) error
|
||||||
|
|
||||||
|
// FeeEstimator calculates appropriate fee rates based on historical
|
||||||
|
// transaction information.
|
||||||
|
FeeEstimator chainfee.Estimator
|
||||||
|
|
||||||
|
// Notifier is used by the FundingManager to determine when the
|
||||||
|
// channel's funding transaction has been confirmed on the blockchain
|
||||||
|
// so that the channel creation process can be completed.
|
||||||
|
Notifier chainntnfs.ChainNotifier
|
||||||
|
|
||||||
|
// SignMessage signs an arbitrary message with a given public key. The
|
||||||
|
// actual digest signed is the double sha-256 of the message. In the
|
||||||
|
// case that the private key corresponding to the passed public key
|
||||||
|
// cannot be located, then an error is returned.
|
||||||
|
//
|
||||||
|
// TODO(roasbeef): should instead pass on this responsibility to a
|
||||||
|
// distinct sub-system?
|
||||||
|
SignMessage func(pubKey *btcec.PublicKey,
|
||||||
|
msg []byte) (input.Signature, error)
|
||||||
|
|
||||||
|
// CurrentNodeAnnouncement should return the latest, fully signed node
|
||||||
|
// announcement from the backing Lightning Network node.
|
||||||
|
CurrentNodeAnnouncement func() (lnwire.NodeAnnouncement, error)
|
||||||
|
|
||||||
|
// SendAnnouncement is used by the FundingManager to send announcement
|
||||||
|
// messages to the Gossiper to possibly broadcast to the greater
|
||||||
|
// network. A set of optional message fields can be provided to populate
|
||||||
|
// any information within the graph that is not included in the gossip
|
||||||
|
// message.
|
||||||
|
SendAnnouncement func(msg lnwire.Message,
|
||||||
|
optionalFields ...discovery.OptionalMsgField) chan error
|
||||||
|
|
||||||
|
// NotifyWhenOnline allows the FundingManager to register with a
|
||||||
|
// subsystem that will notify it when the peer comes online. This is
|
||||||
|
// used when sending the fundingLocked message, since it MUST be
|
||||||
|
// delivered after the funding transaction is confirmed.
|
||||||
|
//
|
||||||
|
// NOTE: The peerChan channel must be buffered.
|
||||||
|
NotifyWhenOnline func(peer [33]byte, peerChan chan<- lnpeer.Peer)
|
||||||
|
|
||||||
|
// FindChannel queries the database for the channel with the given
|
||||||
|
// channel ID.
|
||||||
|
FindChannel func(chanID lnwire.ChannelID) (*channeldb.OpenChannel, error)
|
||||||
|
|
||||||
|
// TempChanIDSeed is a cryptographically random string of bytes that's
|
||||||
|
// used as a seed to generate pending channel ID's.
|
||||||
|
TempChanIDSeed [32]byte
|
||||||
|
|
||||||
|
// DefaultRoutingPolicy is the default routing policy used when
|
||||||
|
// initially announcing channels.
|
||||||
|
DefaultRoutingPolicy htlcswitch.ForwardingPolicy
|
||||||
|
|
||||||
|
// DefaultMinHtlcIn is the default minimum incoming htlc value that is
|
||||||
|
// set as a channel parameter.
|
||||||
|
DefaultMinHtlcIn lnwire.MilliSatoshi
|
||||||
|
|
||||||
|
// NumRequiredConfs is a function closure that helps the funding
|
||||||
|
// manager decide how many confirmations it should require for a
|
||||||
|
// channel extended to it. The function is able to take into account
|
||||||
|
// the amount of the channel, and any funds we'll be pushed in the
|
||||||
|
// process to determine how many confirmations we'll require.
|
||||||
|
NumRequiredConfs func(btcutil.Amount, lnwire.MilliSatoshi) uint16
|
||||||
|
|
||||||
|
// RequiredRemoteDelay is a function that maps the total amount in a
|
||||||
|
// proposed channel to the CSV delay that we'll require for the remote
|
||||||
|
// party. Naturally a larger channel should require a higher CSV delay
|
||||||
|
// in order to give us more time to claim funds in the case of a
|
||||||
|
// contract breach.
|
||||||
|
RequiredRemoteDelay func(btcutil.Amount) uint16
|
||||||
|
|
||||||
|
// RequiredRemoteChanReserve is a function closure that, given the
|
||||||
|
// channel capacity and dust limit, will return an appropriate amount
|
||||||
|
// for the remote peer's required channel reserve that is to be adhered
|
||||||
|
// to at all times.
|
||||||
|
RequiredRemoteChanReserve func(capacity, dustLimit btcutil.Amount) btcutil.Amount
|
||||||
|
|
||||||
|
// RequiredRemoteMaxValue is a function closure that, given the channel
|
||||||
|
// capacity, returns the amount of MilliSatoshis that our remote peer
|
||||||
|
// can have in total outstanding HTLCs with us.
|
||||||
|
RequiredRemoteMaxValue func(btcutil.Amount) lnwire.MilliSatoshi
|
||||||
|
|
||||||
|
// RequiredRemoteMaxHTLCs is a function closure that, given the channel
|
||||||
|
// capacity, returns the number of maximum HTLCs the remote peer can
|
||||||
|
// offer us.
|
||||||
|
RequiredRemoteMaxHTLCs func(btcutil.Amount) uint16
|
||||||
|
|
||||||
|
// WatchNewChannel is to be called once a new channel enters the final
|
||||||
|
// funding stage: waiting for on-chain confirmation. This method sends
|
||||||
|
// the channel to the ChainArbitrator so it can watch for any on-chain
|
||||||
|
// events related to the channel. We also provide the public key of the
|
||||||
|
// node we're establishing a channel with for reconnection purposes.
|
||||||
|
WatchNewChannel func(*channeldb.OpenChannel, *btcec.PublicKey) error
|
||||||
|
|
||||||
|
// ReportShortChanID allows the funding manager to report the newly
|
||||||
|
// discovered short channel ID of a formerly pending channel to outside
|
||||||
|
// sub-systems.
|
||||||
|
ReportShortChanID func(wire.OutPoint) error
|
||||||
|
|
||||||
|
// ZombieSweeperInterval is the periodic time interval in which the
|
||||||
|
// zombie sweeper is run.
|
||||||
|
ZombieSweeperInterval time.Duration
|
||||||
|
|
||||||
|
// ReservationTimeout is the length of idle time that must pass before
|
||||||
|
// a reservation is considered a zombie.
|
||||||
|
ReservationTimeout time.Duration
|
||||||
|
|
||||||
|
// MinChanSize is the smallest channel size that we'll accept as an
|
||||||
|
// inbound channel. We have such a parameter, as otherwise, nodes could
|
||||||
|
// flood us with very small channels that would never really be usable
|
||||||
|
// due to fees.
|
||||||
|
MinChanSize btcutil.Amount
|
||||||
|
|
||||||
|
// MaxChanSize is the largest channel size that we'll accept as an
|
||||||
|
// inbound channel. We have such a parameter, so that you may decide how
|
||||||
|
// WUMBO you would like your channel.
|
||||||
|
MaxChanSize btcutil.Amount
|
||||||
|
|
||||||
|
// MaxPendingChannels is the maximum number of pending channels we
|
||||||
|
// allow for each peer.
|
||||||
|
MaxPendingChannels int
|
||||||
|
|
||||||
|
// RejectPush is set true if the fundingmanager should reject any
|
||||||
|
// incoming channels having a non-zero push amount.
|
||||||
|
RejectPush bool
|
||||||
|
|
||||||
|
// MaxLocalCSVDelay is the maximum csv delay we will allow for our
|
||||||
|
// commit output. Channels that exceed this value will be failed.
|
||||||
|
MaxLocalCSVDelay uint16
|
||||||
|
|
||||||
|
// NotifyOpenChannelEvent informs the ChannelNotifier when channels
|
||||||
|
// transition from pending open to open.
|
||||||
|
NotifyOpenChannelEvent func(wire.OutPoint)
|
||||||
|
|
||||||
|
// OpenChannelPredicate is a predicate on the lnwire.OpenChannel message
|
||||||
|
// and on the requesting node's public key that returns a bool which tells
|
||||||
|
// the funding manager whether or not to accept the channel.
|
||||||
|
OpenChannelPredicate chanacceptor.ChannelAcceptor
|
||||||
|
|
||||||
|
// NotifyPendingOpenChannelEvent informs the ChannelNotifier when channels
|
||||||
|
// enter a pending state.
|
||||||
|
NotifyPendingOpenChannelEvent func(wire.OutPoint, *channeldb.OpenChannel)
|
||||||
|
|
||||||
|
// EnableUpfrontShutdown specifies whether the upfront shutdown script
|
||||||
|
// is enabled.
|
||||||
|
EnableUpfrontShutdown bool
|
||||||
|
|
||||||
|
// RegisteredChains keeps track of all chains that have been registered
|
||||||
|
// with the daemon.
|
||||||
|
RegisteredChains *chainreg.ChainRegistry
|
||||||
|
|
||||||
|
// MaxAnchorsCommitFeeRate is the max commitment fee rate we'll use as
|
||||||
|
// the initiator for channels of the anchor type.
|
||||||
|
MaxAnchorsCommitFeeRate chainfee.SatPerKWeight
|
||||||
|
}
|
||||||
|
|
||||||
|
// Manager acts as an orchestrator/bridge between the wallet's
|
||||||
|
// 'ChannelReservation' workflow, and the wire protocol's funding initiation
|
||||||
|
// messages. Any requests to initiate the funding workflow for a channel,
|
||||||
|
// either kicked-off locally or remotely are handled by the funding manager.
|
||||||
|
// Once a channel's funding workflow has been completed, any local callers, the
|
||||||
|
// local peer, and possibly the remote peer are notified of the completion of
|
||||||
|
// the channel workflow. Additionally, any temporary or permanent access
|
||||||
|
// controls between the wallet and remote peers are enforced via the funding
|
||||||
|
// manager.
|
||||||
|
type Manager struct {
|
||||||
|
started sync.Once
|
||||||
|
stopped sync.Once
|
||||||
|
|
||||||
|
// cfg is a copy of the configuration struct that the FundingManager
|
||||||
|
// was initialized with.
|
||||||
|
cfg *Config
|
||||||
|
|
||||||
|
// chanIDKey is a cryptographically random key that's used to generate
|
||||||
|
// temporary channel ID's.
|
||||||
|
chanIDKey [32]byte
|
||||||
|
|
||||||
|
// chanIDNonce is a nonce that's incremented for each new funding
|
||||||
|
// reservation created.
|
||||||
|
nonceMtx sync.RWMutex
|
||||||
|
chanIDNonce uint64
|
||||||
|
|
||||||
|
// activeReservations is a map which houses the state of all pending
|
||||||
|
// funding workflows.
|
||||||
|
activeReservations map[serializedPubKey]pendingChannels
|
||||||
|
|
||||||
|
// signedReservations is a utility map that maps the permanent channel
|
||||||
|
// ID of a funding reservation to its temporary channel ID. This is
|
||||||
|
// required as mid funding flow, we switch to referencing the channel
|
||||||
|
// by its full channel ID once the commitment transactions have been
|
||||||
|
// signed by both parties.
|
||||||
|
signedReservations map[lnwire.ChannelID][32]byte
|
||||||
|
|
||||||
|
// resMtx guards both of the maps above to ensure that all access is
|
||||||
|
// goroutine safe.
|
||||||
|
resMtx sync.RWMutex
|
||||||
|
|
||||||
|
// fundingMsgs is a channel that relays fundingMsg structs from
|
||||||
|
// external sub-systems using the ProcessFundingMsg call.
|
||||||
|
fundingMsgs chan *fundingMsg
|
||||||
|
|
||||||
|
// fundingRequests is a channel used to receive channel initiation
|
||||||
|
// requests from a local subsystem within the daemon.
|
||||||
|
fundingRequests chan *InitFundingMsg
|
||||||
|
|
||||||
|
// newChanBarriers is a map from a channel ID to a 'barrier' which will
|
||||||
|
// be signalled once the channel is fully open. This barrier acts as a
|
||||||
|
// synchronization point for any incoming/outgoing HTLCs before the
|
||||||
|
// channel has been fully opened.
|
||||||
|
barrierMtx sync.RWMutex
|
||||||
|
newChanBarriers map[lnwire.ChannelID]chan struct{}
|
||||||
|
|
||||||
|
localDiscoveryMtx sync.Mutex
|
||||||
|
localDiscoverySignals map[lnwire.ChannelID]chan struct{}
|
||||||
|
|
||||||
|
handleFundingLockedMtx sync.RWMutex
|
||||||
|
handleFundingLockedBarriers map[lnwire.ChannelID]struct{}
|
||||||
|
|
||||||
|
quit chan struct{}
|
||||||
|
wg sync.WaitGroup
|
||||||
|
}
|
||||||
|
|
||||||
|
// channelOpeningState represents the different states a channel can be in
|
||||||
|
// between the funding transaction has been confirmed and the channel is
|
||||||
|
// announced to the network and ready to be used.
|
||||||
|
type channelOpeningState uint8
|
||||||
|
|
||||||
|
const (
|
||||||
|
// markedOpen is the opening state of a channel if the funding
|
||||||
|
// transaction is confirmed on-chain, but fundingLocked is not yet
|
||||||
|
// successfully sent to the other peer.
|
||||||
|
markedOpen channelOpeningState = iota
|
||||||
|
|
||||||
|
// fundingLockedSent is the opening state of a channel if the
|
||||||
|
// fundingLocked message has successfully been sent to the other peer,
|
||||||
|
// but we still haven't announced the channel to the network.
|
||||||
|
fundingLockedSent
|
||||||
|
|
||||||
|
// addedToRouterGraph is the opening state of a channel if the
|
||||||
|
// channel has been successfully added to the router graph
|
||||||
|
// immediately after the fundingLocked message has been sent, but
|
||||||
|
// we still haven't announced the channel to the network.
|
||||||
|
addedToRouterGraph
|
||||||
|
)
|
||||||
|
|
||||||
|
var (
|
||||||
|
// channelOpeningStateBucket is the database bucket used to store the
|
||||||
|
// channelOpeningState for each channel that is currently in the process
|
||||||
|
// of being opened.
|
||||||
|
channelOpeningStateBucket = []byte("channelOpeningState")
|
||||||
|
|
||||||
|
// ErrChannelNotFound is an error returned when a channel is not known
|
||||||
|
// to us. In this case of the fundingManager, this error is returned
|
||||||
|
// when the channel in question is not considered being in an opening
|
||||||
|
// state.
|
||||||
|
ErrChannelNotFound = fmt.Errorf("channel not found")
|
||||||
|
)
|
||||||
|
|
||||||
|
// NewFundingManager creates and initializes a new instance of the
|
||||||
|
// fundingManager.
|
||||||
|
func NewFundingManager(cfg Config) (*Manager, error) {
|
||||||
|
return &Manager{
|
||||||
|
cfg: &cfg,
|
||||||
|
chanIDKey: cfg.TempChanIDSeed,
|
||||||
|
activeReservations: make(map[serializedPubKey]pendingChannels),
|
||||||
|
signedReservations: make(map[lnwire.ChannelID][32]byte),
|
||||||
|
newChanBarriers: make(map[lnwire.ChannelID]chan struct{}),
|
||||||
|
fundingMsgs: make(chan *fundingMsg, msgBufferSize),
|
||||||
|
fundingRequests: make(chan *InitFundingMsg, msgBufferSize),
|
||||||
|
localDiscoverySignals: make(map[lnwire.ChannelID]chan struct{}),
|
||||||
|
handleFundingLockedBarriers: make(map[lnwire.ChannelID]struct{}),
|
||||||
|
quit: make(chan struct{}),
|
||||||
|
}, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// Start launches all helper goroutines required for handling requests sent
|
||||||
|
// to the funding manager.
|
||||||
|
func (f *Manager) Start() error {
|
||||||
|
var err error
|
||||||
|
f.started.Do(func() {
|
||||||
|
err = f.start()
|
||||||
|
})
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
func (f *Manager) start() error {
|
||||||
|
log.Tracef("Funding manager running")
|
||||||
|
|
||||||
|
// Upon restart, the Funding Manager will check the database to load any
|
||||||
|
// channels that were waiting for their funding transactions to be
|
||||||
|
// confirmed on the blockchain at the time when the daemon last went
|
||||||
|
// down.
|
||||||
|
// TODO(roasbeef): store height that funding finished?
|
||||||
|
// * would then replace call below
|
||||||
|
allChannels, err := f.cfg.Wallet.Cfg.Database.FetchAllChannels()
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
for _, channel := range allChannels {
|
||||||
|
chanID := lnwire.NewChanIDFromOutPoint(&channel.FundingOutpoint)
|
||||||
|
|
||||||
|
// For any channels that were in a pending state when the
|
||||||
|
// daemon was last connected, the Funding Manager will
|
||||||
|
// re-initialize the channel barriers, and republish the
|
||||||
|
// funding transaction if we're the initiator.
|
||||||
|
if channel.IsPending {
|
||||||
|
f.barrierMtx.Lock()
|
||||||
|
log.Tracef("Loading pending ChannelPoint(%v), "+
|
||||||
|
"creating chan barrier",
|
||||||
|
channel.FundingOutpoint)
|
||||||
|
|
||||||
|
f.newChanBarriers[chanID] = make(chan struct{})
|
||||||
|
f.barrierMtx.Unlock()
|
||||||
|
|
||||||
|
f.localDiscoverySignals[chanID] = make(chan struct{})
|
||||||
|
|
||||||
|
// Rebroadcast the funding transaction for any pending
|
||||||
|
// channel that we initiated. No error will be returned
|
||||||
|
// if the transaction already has been broadcast.
|
||||||
|
chanType := channel.ChanType
|
||||||
|
if chanType.IsSingleFunder() && chanType.HasFundingTx() &&
|
||||||
|
channel.IsInitiator {
|
||||||
|
|
||||||
|
var fundingTxBuf bytes.Buffer
|
||||||
|
err := channel.FundingTxn.Serialize(&fundingTxBuf)
|
||||||
|
if err != nil {
|
||||||
|
log.Errorf("Unable to serialize "+
|
||||||
|
"funding transaction %v: %v",
|
||||||
|
channel.FundingTxn.TxHash(), err)
|
||||||
|
|
||||||
|
// Clear the buffer of any bytes that
|
||||||
|
// were written before the serialization
|
||||||
|
// error to prevent logging an
|
||||||
|
// incomplete transaction.
|
||||||
|
fundingTxBuf.Reset()
|
||||||
|
}
|
||||||
|
|
||||||
|
log.Debugf("Rebroadcasting funding tx for "+
|
||||||
|
"ChannelPoint(%v): %x",
|
||||||
|
channel.FundingOutpoint,
|
||||||
|
fundingTxBuf.Bytes())
|
||||||
|
|
||||||
|
// Set a nil short channel ID at this stage
|
||||||
|
// because we do not know it until our funding
|
||||||
|
// tx confirms.
|
||||||
|
label := labels.MakeLabel(
|
||||||
|
labels.LabelTypeChannelOpen, nil,
|
||||||
|
)
|
||||||
|
|
||||||
|
err = f.cfg.PublishTransaction(
|
||||||
|
channel.FundingTxn, label,
|
||||||
|
)
|
||||||
|
if err != nil {
|
||||||
|
log.Errorf("Unable to rebroadcast "+
|
||||||
|
"funding tx %x for "+
|
||||||
|
"ChannelPoint(%v): %v",
|
||||||
|
fundingTxBuf.Bytes(),
|
||||||
|
channel.FundingOutpoint, err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// We will restart the funding state machine for all channels,
|
||||||
|
// which will wait for the channel's funding transaction to be
|
||||||
|
// confirmed on the blockchain, and transmit the messages
|
||||||
|
// necessary for the channel to be operational.
|
||||||
|
f.wg.Add(1)
|
||||||
|
go f.advanceFundingState(channel, chanID, nil)
|
||||||
|
}
|
||||||
|
|
||||||
|
f.wg.Add(1) // TODO(roasbeef): tune
|
||||||
|
go f.reservationCoordinator()
|
||||||
|
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// Stop signals all helper goroutines to execute a graceful shutdown. This
|
||||||
|
// method will block until all goroutines have exited.
|
||||||
|
func (f *Manager) Stop() {
|
||||||
|
f.stopped.Do(func() {
|
||||||
|
log.Info("Funding manager shutting down")
|
||||||
|
close(f.quit)
|
||||||
|
f.wg.Wait()
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
// nextPendingChanID returns the next free pending channel ID to be used to
|
||||||
|
// identify a particular future channel funding workflow.
|
||||||
|
func (f *Manager) nextPendingChanID() [32]byte {
|
||||||
|
// Obtain a fresh nonce. We do this by encoding the current nonce
|
||||||
|
// counter, then incrementing it by one.
|
||||||
|
f.nonceMtx.Lock()
|
||||||
|
var nonce [8]byte
|
||||||
|
binary.LittleEndian.PutUint64(nonce[:], f.chanIDNonce)
|
||||||
|
f.chanIDNonce++
|
||||||
|
f.nonceMtx.Unlock()
|
||||||
|
|
||||||
|
// We'll generate the next pending channelID by "encrypting" 32-bytes
|
||||||
|
// of zeroes which'll extract 32 random bytes from our stream cipher.
|
||||||
|
var (
|
||||||
|
nextChanID [32]byte
|
||||||
|
zeroes [32]byte
|
||||||
|
)
|
||||||
|
salsa20.XORKeyStream(nextChanID[:], zeroes[:], nonce[:], &f.chanIDKey)
|
||||||
|
|
||||||
|
return nextChanID
|
||||||
|
}
|
||||||
|
|
||||||
|
// CancelPeerReservations cancels all active reservations associated with the
|
||||||
|
// passed node. This will ensure any outputs which have been pre committed,
|
||||||
|
// (and thus locked from coin selection), are properly freed.
|
||||||
|
func (f *Manager) CancelPeerReservations(nodePub [33]byte) {
|
||||||
|
|
||||||
|
log.Debugf("Cancelling all reservations for peer %x", nodePub[:])
|
||||||
|
|
||||||
|
f.resMtx.Lock()
|
||||||
|
defer f.resMtx.Unlock()
|
||||||
|
|
||||||
|
// We'll attempt to look up this node in the set of active
|
||||||
|
// reservations. If they don't have any, then there's no further work
|
||||||
|
// to be done.
|
||||||
|
nodeReservations, ok := f.activeReservations[nodePub]
|
||||||
|
if !ok {
|
||||||
|
log.Debugf("No active reservations for node: %x", nodePub[:])
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// If they do have any active reservations, then we'll cancel all of
|
||||||
|
// them (which releases any locked UTXO's), and also delete it from the
|
||||||
|
// reservation map.
|
||||||
|
for pendingID, resCtx := range nodeReservations {
|
||||||
|
if err := resCtx.reservation.Cancel(); err != nil {
|
||||||
|
log.Errorf("unable to cancel reservation for "+
|
||||||
|
"node=%x: %v", nodePub[:], err)
|
||||||
|
}
|
||||||
|
|
||||||
|
resCtx.err <- fmt.Errorf("peer disconnected")
|
||||||
|
delete(nodeReservations, pendingID)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Finally, we'll delete the node itself from the set of reservations.
|
||||||
|
delete(f.activeReservations, nodePub)
|
||||||
|
}
|
||||||
|
|
||||||
|
// failFundingFlow will fail the active funding flow with the target peer,
|
||||||
|
// identified by its unique temporary channel ID. This method will send an
|
||||||
|
// error to the remote peer, and also remove the reservation from our set of
|
||||||
|
// pending reservations.
|
||||||
|
//
|
||||||
|
// TODO(roasbeef): if peer disconnects, and haven't yet broadcast funding
|
||||||
|
// transaction, then all reservations should be cleared.
|
||||||
|
func (f *Manager) failFundingFlow(peer lnpeer.Peer, tempChanID [32]byte,
|
||||||
|
fundingErr error) {
|
||||||
|
|
||||||
|
log.Debugf("Failing funding flow for pending_id=%x: %v",
|
||||||
|
tempChanID, fundingErr)
|
||||||
|
|
||||||
|
ctx, err := f.cancelReservationCtx(peer.IdentityKey(), tempChanID, false)
|
||||||
|
if err != nil {
|
||||||
|
log.Errorf("unable to cancel reservation: %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
// In case the case where the reservation existed, send the funding
|
||||||
|
// error on the error channel.
|
||||||
|
if ctx != nil {
|
||||||
|
ctx.err <- fundingErr
|
||||||
|
}
|
||||||
|
|
||||||
|
// We only send the exact error if it is part of out whitelisted set of
|
||||||
|
// errors (lnwire.FundingError or lnwallet.ReservationError).
|
||||||
|
var msg lnwire.ErrorData
|
||||||
|
switch e := fundingErr.(type) {
|
||||||
|
|
||||||
|
// Let the actual error message be sent to the remote for the
|
||||||
|
// whitelisted types.
|
||||||
|
case lnwallet.ReservationError:
|
||||||
|
msg = lnwire.ErrorData(e.Error())
|
||||||
|
case lnwire.FundingError:
|
||||||
|
msg = lnwire.ErrorData(e.Error())
|
||||||
|
case chanacceptor.ChanAcceptError:
|
||||||
|
msg = lnwire.ErrorData(e.Error())
|
||||||
|
|
||||||
|
// For all other error types we just send a generic error.
|
||||||
|
default:
|
||||||
|
msg = lnwire.ErrorData("funding failed due to internal error")
|
||||||
|
}
|
||||||
|
|
||||||
|
errMsg := &lnwire.Error{
|
||||||
|
ChanID: tempChanID,
|
||||||
|
Data: msg,
|
||||||
|
}
|
||||||
|
|
||||||
|
log.Debugf("Sending funding error to peer (%x): %v",
|
||||||
|
peer.IdentityKey().SerializeCompressed(), spew.Sdump(errMsg))
|
||||||
|
if err := peer.SendMessage(false, errMsg); err != nil {
|
||||||
|
log.Errorf("unable to send error message to peer %v", err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// reservationCoordinator is the primary goroutine tasked with progressing the
|
||||||
|
// funding workflow between the wallet, and any outside peers or local callers.
|
||||||
|
//
|
||||||
|
// NOTE: This MUST be run as a goroutine.
|
||||||
|
func (f *Manager) reservationCoordinator() {
|
||||||
|
defer f.wg.Done()
|
||||||
|
|
||||||
|
zombieSweepTicker := time.NewTicker(f.cfg.ZombieSweeperInterval)
|
||||||
|
defer zombieSweepTicker.Stop()
|
||||||
|
|
||||||
|
for {
|
||||||
|
select {
|
||||||
|
|
||||||
|
case fmsg := <-f.fundingMsgs:
|
||||||
|
switch msg := fmsg.msg.(type) {
|
||||||
|
case *lnwire.OpenChannel:
|
||||||
|
f.handleFundingOpen(fmsg.peer, msg)
|
||||||
|
case *lnwire.AcceptChannel:
|
||||||
|
f.handleFundingAccept(fmsg.peer, msg)
|
||||||
|
case *lnwire.FundingCreated:
|
||||||
|
f.handleFundingCreated(fmsg.peer, msg)
|
||||||
|
case *lnwire.FundingSigned:
|
||||||
|
f.handleFundingSigned(fmsg.peer, msg)
|
||||||
|
case *lnwire.FundingLocked:
|
||||||
|
f.wg.Add(1)
|
||||||
|
go f.handleFundingLocked(fmsg.peer, msg)
|
||||||
|
case *lnwire.Error:
|
||||||
|
f.handleErrorMsg(fmsg.peer, msg)
|
||||||
|
}
|
||||||
|
case req := <-f.fundingRequests:
|
||||||
|
f.handleInitFundingMsg(req)
|
||||||
|
|
||||||
|
case <-zombieSweepTicker.C:
|
||||||
|
f.pruneZombieReservations()
|
||||||
|
|
||||||
|
case <-f.quit:
|
||||||
|
return
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// advanceFundingState will advance the channel through the steps after the
|
||||||
|
// funding transaction is broadcasted, up until the point where the channel is
|
||||||
|
// ready for operation. This includes waiting for the funding transaction to
|
||||||
|
// confirm, sending funding locked to the peer, adding the channel to the
|
||||||
|
// router graph, and announcing the channel. The updateChan can be set non-nil
|
||||||
|
// to get OpenStatusUpdates.
|
||||||
|
//
|
||||||
|
// NOTE: This MUST be run as a goroutine.
|
||||||
|
func (f *Manager) advanceFundingState(channel *channeldb.OpenChannel,
|
||||||
|
pendingChanID [32]byte, updateChan chan<- *lnrpc.OpenStatusUpdate) {
|
||||||
|
|
||||||
|
defer f.wg.Done()
|
||||||
|
|
||||||
|
// If the channel is still pending we must wait for the funding
|
||||||
|
// transaction to confirm.
|
||||||
|
if channel.IsPending {
|
||||||
|
err := f.advancePendingChannelState(channel, pendingChanID)
|
||||||
|
if err != nil {
|
||||||
|
log.Errorf("Unable to advance pending state of "+
|
||||||
|
"ChannelPoint(%v): %v",
|
||||||
|
channel.FundingOutpoint, err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// We create the state-machine object which wraps the database state.
|
||||||
|
lnChannel, err := lnwallet.NewLightningChannel(
|
||||||
|
nil, channel, nil,
|
||||||
|
)
|
||||||
|
if err != nil {
|
||||||
|
log.Errorf("Unable to create LightningChannel(%v): %v",
|
||||||
|
channel.FundingOutpoint, err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
for {
|
||||||
|
channelState, shortChanID, err := f.getChannelOpeningState(
|
||||||
|
&channel.FundingOutpoint,
|
||||||
|
)
|
||||||
|
if err == ErrChannelNotFound {
|
||||||
|
// Channel not in fundingManager's opening database,
|
||||||
|
// meaning it was successfully announced to the
|
||||||
|
// network.
|
||||||
|
// TODO(halseth): could do graph consistency check
|
||||||
|
// here, and re-add the edge if missing.
|
||||||
|
log.Debugf("ChannelPoint(%v) with chan_id=%x not "+
|
||||||
|
"found in opening database, assuming already "+
|
||||||
|
"announced to the network",
|
||||||
|
channel.FundingOutpoint, pendingChanID)
|
||||||
|
return
|
||||||
|
} else if err != nil {
|
||||||
|
log.Errorf("Unable to query database for "+
|
||||||
|
"channel opening state(%v): %v",
|
||||||
|
channel.FundingOutpoint, err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// If we did find the channel in the opening state database, we
|
||||||
|
// have seen the funding transaction being confirmed, but there
|
||||||
|
// are still steps left of the setup procedure. We continue the
|
||||||
|
// procedure where we left off.
|
||||||
|
err = f.stateStep(
|
||||||
|
channel, lnChannel, shortChanID, pendingChanID,
|
||||||
|
channelState, updateChan,
|
||||||
|
)
|
||||||
|
if err != nil {
|
||||||
|
log.Errorf("Unable to advance state(%v): %v",
|
||||||
|
channel.FundingOutpoint, err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// stateStep advances the confirmed channel one step in the funding state
|
||||||
|
// machine. This method is synchronous and the new channel opening state will
|
||||||
|
// have been written to the database when it successfully returns. The
|
||||||
|
// updateChan can be set non-nil to get OpenStatusUpdates.
|
||||||
|
func (f *Manager) stateStep(channel *channeldb.OpenChannel,
|
||||||
|
lnChannel *lnwallet.LightningChannel,
|
||||||
|
shortChanID *lnwire.ShortChannelID, pendingChanID [32]byte,
|
||||||
|
channelState channelOpeningState,
|
||||||
|
updateChan chan<- *lnrpc.OpenStatusUpdate) error {
|
||||||
|
|
||||||
|
chanID := lnwire.NewChanIDFromOutPoint(&channel.FundingOutpoint)
|
||||||
|
log.Debugf("Channel(%v) with ShortChanID %v has opening state %v",
|
||||||
|
chanID, shortChanID, channelState)
|
||||||
|
|
||||||
|
switch channelState {
|
||||||
|
|
||||||
|
// The funding transaction was confirmed, but we did not successfully
|
||||||
|
// send the fundingLocked message to the peer, so let's do that now.
|
||||||
|
case markedOpen:
|
||||||
|
err := f.sendFundingLocked(channel, lnChannel, shortChanID)
|
||||||
|
if err != nil {
|
||||||
|
return fmt.Errorf("failed sending fundingLocked: %v",
|
||||||
|
err)
|
||||||
|
}
|
||||||
|
|
||||||
|
// As the fundingLocked message is now sent to the peer, the
|
||||||
|
// channel is moved to the next state of the state machine. It
|
||||||
|
// will be moved to the last state (actually deleted from the
|
||||||
|
// database) after the channel is finally announced.
|
||||||
|
err = f.saveChannelOpeningState(
|
||||||
|
&channel.FundingOutpoint, fundingLockedSent,
|
||||||
|
shortChanID,
|
||||||
|
)
|
||||||
|
if err != nil {
|
||||||
|
return fmt.Errorf("error setting channel state to"+
|
||||||
|
" fundingLockedSent: %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
log.Debugf("Channel(%v) with ShortChanID %v: successfully "+
|
||||||
|
"sent FundingLocked", chanID, shortChanID)
|
||||||
|
|
||||||
|
return nil
|
||||||
|
|
||||||
|
// fundingLocked was sent to peer, but the channel was not added to the
|
||||||
|
// router graph and the channel announcement was not sent.
|
||||||
|
case fundingLockedSent:
|
||||||
|
err := f.addToRouterGraph(channel, shortChanID)
|
||||||
|
if err != nil {
|
||||||
|
return fmt.Errorf("failed adding to "+
|
||||||
|
"router graph: %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
// As the channel is now added to the ChannelRouter's topology,
|
||||||
|
// the channel is moved to the next state of the state machine.
|
||||||
|
// It will be moved to the last state (actually deleted from
|
||||||
|
// the database) after the channel is finally announced.
|
||||||
|
err = f.saveChannelOpeningState(
|
||||||
|
&channel.FundingOutpoint, addedToRouterGraph,
|
||||||
|
shortChanID,
|
||||||
|
)
|
||||||
|
if err != nil {
|
||||||
|
return fmt.Errorf("error setting channel state to"+
|
||||||
|
" addedToRouterGraph: %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
log.Debugf("Channel(%v) with ShortChanID %v: successfully "+
|
||||||
|
"added to router graph", chanID, shortChanID)
|
||||||
|
|
||||||
|
// Give the caller a final update notifying them that
|
||||||
|
// the channel is now open.
|
||||||
|
// TODO(roasbeef): only notify after recv of funding locked?
|
||||||
|
fundingPoint := channel.FundingOutpoint
|
||||||
|
cp := &lnrpc.ChannelPoint{
|
||||||
|
FundingTxid: &lnrpc.ChannelPoint_FundingTxidBytes{
|
||||||
|
FundingTxidBytes: fundingPoint.Hash[:],
|
||||||
|
},
|
||||||
|
OutputIndex: fundingPoint.Index,
|
||||||
|
}
|
||||||
|
|
||||||
|
if updateChan != nil {
|
||||||
|
upd := &lnrpc.OpenStatusUpdate{
|
||||||
|
Update: &lnrpc.OpenStatusUpdate_ChanOpen{
|
||||||
|
ChanOpen: &lnrpc.ChannelOpenUpdate{
|
||||||
|
ChannelPoint: cp,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
PendingChanId: pendingChanID[:],
|
||||||
|
}
|
||||||
|
|
||||||
|
select {
|
||||||
|
case updateChan <- upd:
|
||||||
|
case <-f.quit:
|
||||||
|
return ErrFundingManagerShuttingDown
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
return nil
|
||||||
|
|
||||||
|
// The channel was added to the Router's topology, but the channel
|
||||||
|
// announcement was not sent.
|
||||||
|
case addedToRouterGraph:
|
||||||
|
err := f.annAfterSixConfs(channel, shortChanID)
|
||||||
|
if err != nil {
|
||||||
|
return fmt.Errorf("error sending channel "+
|
||||||
|
"announcement: %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
// We delete the channel opening state from our internal
|
||||||
|
// database as the opening process has succeeded. We can do
|
||||||
|
// this because we assume the AuthenticatedGossiper queues the
|
||||||
|
// announcement messages, and persists them in case of a daemon
|
||||||
|
// shutdown.
|
||||||
|
err = f.deleteChannelOpeningState(&channel.FundingOutpoint)
|
||||||
|
if err != nil {
|
||||||
|
return fmt.Errorf("error deleting channel state: %v",
|
||||||
|
err)
|
||||||
|
}
|
||||||
|
|
||||||
|
log.Debugf("Channel(%v) with ShortChanID %v: successfully "+
|
||||||
|
"announced", chanID, shortChanID)
|
||||||
|
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
return fmt.Errorf("undefined channelState: %v", channelState)
|
||||||
|
}
|
||||||
|
|
||||||
|
// advancePendingChannelState waits for a pending channel's funding tx to
|
||||||
|
// confirm, and marks it open in the database when that happens.
|
||||||
|
func (f *Manager) advancePendingChannelState(
|
||||||
|
channel *channeldb.OpenChannel, pendingChanID [32]byte) error {
|
||||||
|
|
||||||
|
confChannel, err := f.waitForFundingWithTimeout(channel)
|
||||||
|
if err == ErrConfirmationTimeout {
|
||||||
|
// We'll get a timeout if the number of blocks mined
|
||||||
|
// since the channel was initiated reaches
|
||||||
|
// maxWaitNumBlocksFundingConf and we are not the
|
||||||
|
// channel initiator.
|
||||||
|
ch := channel
|
||||||
|
localBalance := ch.LocalCommitment.LocalBalance.ToSatoshis()
|
||||||
|
closeInfo := &channeldb.ChannelCloseSummary{
|
||||||
|
ChainHash: ch.ChainHash,
|
||||||
|
ChanPoint: ch.FundingOutpoint,
|
||||||
|
RemotePub: ch.IdentityPub,
|
||||||
|
Capacity: ch.Capacity,
|
||||||
|
SettledBalance: localBalance,
|
||||||
|
CloseType: channeldb.FundingCanceled,
|
||||||
|
RemoteCurrentRevocation: ch.RemoteCurrentRevocation,
|
||||||
|
RemoteNextRevocation: ch.RemoteNextRevocation,
|
||||||
|
LocalChanConfig: ch.LocalChanCfg,
|
||||||
|
}
|
||||||
|
|
||||||
|
// Close the channel with us as the initiator because we are
|
||||||
|
// timing the channel out.
|
||||||
|
if err := ch.CloseChannel(
|
||||||
|
closeInfo, channeldb.ChanStatusLocalCloseInitiator,
|
||||||
|
); err != nil {
|
||||||
|
return fmt.Errorf("failed closing channel "+
|
||||||
|
"%v: %v", ch.FundingOutpoint, err)
|
||||||
|
}
|
||||||
|
|
||||||
|
timeoutErr := fmt.Errorf("timeout waiting for funding tx "+
|
||||||
|
"(%v) to confirm", channel.FundingOutpoint)
|
||||||
|
|
||||||
|
// When the peer comes online, we'll notify it that we
|
||||||
|
// are now considering the channel flow canceled.
|
||||||
|
f.wg.Add(1)
|
||||||
|
go func() {
|
||||||
|
defer f.wg.Done()
|
||||||
|
|
||||||
|
peerChan := make(chan lnpeer.Peer, 1)
|
||||||
|
var peerKey [33]byte
|
||||||
|
copy(peerKey[:], ch.IdentityPub.SerializeCompressed())
|
||||||
|
|
||||||
|
f.cfg.NotifyWhenOnline(peerKey, peerChan)
|
||||||
|
|
||||||
|
var peer lnpeer.Peer
|
||||||
|
select {
|
||||||
|
case peer = <-peerChan:
|
||||||
|
case <-f.quit:
|
||||||
|
return
|
||||||
|
}
|
||||||
|
// TODO(halseth): should this send be made
|
||||||
|
// reliable?
|
||||||
|
f.failFundingFlow(peer, pendingChanID, timeoutErr)
|
||||||
|
}()
|
||||||
|
|
||||||
|
return timeoutErr
|
||||||
|
|
||||||
|
} else if err != nil {
|
||||||
|
return fmt.Errorf("error waiting for funding "+
|
||||||
|
"confirmation for ChannelPoint(%v): %v",
|
||||||
|
channel.FundingOutpoint, err)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Success, funding transaction was confirmed.
|
||||||
|
chanID := lnwire.NewChanIDFromOutPoint(&channel.FundingOutpoint)
|
||||||
|
log.Debugf("ChannelID(%v) is now fully confirmed! "+
|
||||||
|
"(shortChanID=%v)", chanID, confChannel.shortChanID)
|
||||||
|
|
||||||
|
err = f.handleFundingConfirmation(channel, confChannel)
|
||||||
|
if err != nil {
|
||||||
|
return fmt.Errorf("unable to handle funding "+
|
||||||
|
"confirmation for ChannelPoint(%v): %v",
|
||||||
|
channel.FundingOutpoint, err)
|
||||||
|
}
|
||||||
|
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// ProcessFundingMsg sends a message to the internal fundingManager goroutine,
|
||||||
|
// allowing it to handle the lnwire.Message.
|
||||||
|
func (f *Manager) ProcessFundingMsg(msg lnwire.Message, peer lnpeer.Peer) {
|
||||||
|
select {
|
||||||
|
case f.fundingMsgs <- &fundingMsg{msg, peer}:
|
||||||
|
case <-f.quit:
|
||||||
|
return
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// commitmentType returns the commitment type to use for the channel, based on
|
||||||
|
// the features the two peers have available.
|
||||||
|
func commitmentType(localFeatures,
|
||||||
|
remoteFeatures *lnwire.FeatureVector) lnwallet.CommitmentType {
|
||||||
|
|
||||||
|
// If both peers are signalling support for anchor commitments with
|
||||||
|
// zero-fee HTLC transactions, we'll use this type.
|
||||||
|
localZeroFee := localFeatures.HasFeature(
|
||||||
|
lnwire.AnchorsZeroFeeHtlcTxOptional,
|
||||||
|
)
|
||||||
|
remoteZeroFee := remoteFeatures.HasFeature(
|
||||||
|
lnwire.AnchorsZeroFeeHtlcTxOptional,
|
||||||
|
)
|
||||||
|
if localZeroFee && remoteZeroFee {
|
||||||
|
return lnwallet.CommitmentTypeAnchorsZeroFeeHtlcTx
|
||||||
|
}
|
||||||
|
|
||||||
|
// Since we don't want to support the "legacy" anchor type, we will
|
||||||
|
// fall back to static remote key if the nodes don't support the zero
|
||||||
|
// fee HTLC tx anchor type.
|
||||||
|
localTweakless := localFeatures.HasFeature(
|
||||||
|
lnwire.StaticRemoteKeyOptional,
|
||||||
|
)
|
||||||
|
remoteTweakless := remoteFeatures.HasFeature(
|
||||||
|
lnwire.StaticRemoteKeyOptional,
|
||||||
|
)
|
||||||
|
|
||||||
|
// If both nodes are signaling the proper feature bit for tweakless
|
||||||
|
// copmmitments, we'll use that.
|
||||||
|
if localTweakless && remoteTweakless {
|
||||||
|
return lnwallet.CommitmentTypeTweakless
|
||||||
|
}
|
||||||
|
|
||||||
|
// Otherwise we'll fall back to the legacy type.
|
||||||
|
return lnwallet.CommitmentTypeLegacy
|
||||||
|
}
|
||||||
|
|
||||||
|
// handleFundingOpen creates an initial 'ChannelReservation' within the wallet,
|
||||||
|
// then responds to the source peer with an accept channel message progressing
|
||||||
|
// the funding workflow.
|
||||||
|
//
|
||||||
|
// TODO(roasbeef): add error chan to all, let channelManager handle
|
||||||
|
// error+propagate
|
||||||
|
func (f *Manager) handleFundingOpen(peer lnpeer.Peer,
|
||||||
|
msg *lnwire.OpenChannel) {
|
||||||
|
|
||||||
|
// Check number of pending channels to be smaller than maximum allowed
|
||||||
|
// number and send ErrorGeneric to remote peer if condition is
|
||||||
|
// violated.
|
||||||
|
peerPubKey := peer.IdentityKey()
|
||||||
|
peerIDKey := newSerializedKey(peerPubKey)
|
||||||
|
|
||||||
|
amt := msg.FundingAmount
|
||||||
|
|
||||||
|
// We get all pending channels for this peer. This is the list of the
|
||||||
|
// active reservations and the channels pending open in the database.
|
||||||
|
f.resMtx.RLock()
|
||||||
|
reservations := f.activeReservations[peerIDKey]
|
||||||
|
|
||||||
|
// We don't count reservations that were created from a canned funding
|
||||||
|
// shim. The user has registered the shim and therefore expects this
|
||||||
|
// channel to arrive.
|
||||||
|
numPending := 0
|
||||||
|
for _, res := range reservations {
|
||||||
|
if !res.reservation.IsCannedShim() {
|
||||||
|
numPending++
|
||||||
|
}
|
||||||
|
}
|
||||||
|
f.resMtx.RUnlock()
|
||||||
|
|
||||||
|
// Also count the channels that are already pending. There we don't know
|
||||||
|
// the underlying intent anymore, unfortunately.
|
||||||
|
channels, err := f.cfg.Wallet.Cfg.Database.FetchOpenChannels(peerPubKey)
|
||||||
|
if err != nil {
|
||||||
|
f.failFundingFlow(
|
||||||
|
peer, msg.PendingChannelID, err,
|
||||||
|
)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
for _, c := range channels {
|
||||||
|
// Pending channels that have a non-zero thaw height were also
|
||||||
|
// created through a canned funding shim. Those also don't
|
||||||
|
// count towards the DoS protection limit.
|
||||||
|
//
|
||||||
|
// TODO(guggero): Properly store the funding type (wallet, shim,
|
||||||
|
// PSBT) on the channel so we don't need to use the thaw height.
|
||||||
|
if c.IsPending && c.ThawHeight == 0 {
|
||||||
|
numPending++
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// TODO(roasbeef): modify to only accept a _single_ pending channel per
|
||||||
|
// block unless white listed
|
||||||
|
if numPending >= f.cfg.MaxPendingChannels {
|
||||||
|
f.failFundingFlow(
|
||||||
|
peer, msg.PendingChannelID,
|
||||||
|
lnwire.ErrMaxPendingChannels,
|
||||||
|
)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// We'll also reject any requests to create channels until we're fully
|
||||||
|
// synced to the network as we won't be able to properly validate the
|
||||||
|
// confirmation of the funding transaction.
|
||||||
|
isSynced, _, err := f.cfg.Wallet.IsSynced()
|
||||||
|
if err != nil || !isSynced {
|
||||||
|
if err != nil {
|
||||||
|
log.Errorf("unable to query wallet: %v", err)
|
||||||
|
}
|
||||||
|
f.failFundingFlow(
|
||||||
|
peer, msg.PendingChannelID,
|
||||||
|
lnwire.ErrSynchronizingChain,
|
||||||
|
)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// Ensure that the remote party respects our maximum channel size.
|
||||||
|
if amt > f.cfg.MaxChanSize {
|
||||||
|
f.failFundingFlow(
|
||||||
|
peer, msg.PendingChannelID,
|
||||||
|
lnwallet.ErrChanTooLarge(amt, f.cfg.MaxChanSize),
|
||||||
|
)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// We'll, also ensure that the remote party isn't attempting to propose
|
||||||
|
// a channel that's below our current min channel size.
|
||||||
|
if amt < f.cfg.MinChanSize {
|
||||||
|
f.failFundingFlow(
|
||||||
|
peer, msg.PendingChannelID,
|
||||||
|
lnwallet.ErrChanTooSmall(amt, btcutil.Amount(f.cfg.MinChanSize)),
|
||||||
|
)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// If request specifies non-zero push amount and 'rejectpush' is set,
|
||||||
|
// signal an error.
|
||||||
|
if f.cfg.RejectPush && msg.PushAmount > 0 {
|
||||||
|
f.failFundingFlow(
|
||||||
|
peer, msg.PendingChannelID,
|
||||||
|
lnwallet.ErrNonZeroPushAmount(),
|
||||||
|
)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// Send the OpenChannel request to the ChannelAcceptor to determine whether
|
||||||
|
// this node will accept the channel.
|
||||||
|
chanReq := &chanacceptor.ChannelAcceptRequest{
|
||||||
|
Node: peer.IdentityKey(),
|
||||||
|
OpenChanMsg: msg,
|
||||||
|
}
|
||||||
|
|
||||||
|
// Query our channel acceptor to determine whether we should reject
|
||||||
|
// the channel.
|
||||||
|
acceptorResp := f.cfg.OpenChannelPredicate.Accept(chanReq)
|
||||||
|
if acceptorResp.RejectChannel() {
|
||||||
|
f.failFundingFlow(
|
||||||
|
peer, msg.PendingChannelID,
|
||||||
|
acceptorResp.ChanAcceptError,
|
||||||
|
)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
log.Infof("Recv'd fundingRequest(amt=%v, push=%v, delay=%v, "+
|
||||||
|
"pendingId=%x) from peer(%x)", amt, msg.PushAmount,
|
||||||
|
msg.CsvDelay, msg.PendingChannelID,
|
||||||
|
peer.IdentityKey().SerializeCompressed())
|
||||||
|
|
||||||
|
// Attempt to initialize a reservation within the wallet. If the wallet
|
||||||
|
// has insufficient resources to create the channel, then the
|
||||||
|
// reservation attempt may be rejected. Note that since we're on the
|
||||||
|
// responding side of a single funder workflow, we don't commit any
|
||||||
|
// funds to the channel ourselves.
|
||||||
|
//
|
||||||
|
// Before we init the channel, we'll also check to see what commitment
|
||||||
|
// format we can use with this peer. This is dependent on *both* us and
|
||||||
|
// the remote peer are signaling the proper feature bit.
|
||||||
|
commitType := commitmentType(
|
||||||
|
peer.LocalFeatures(), peer.RemoteFeatures(),
|
||||||
|
)
|
||||||
|
chainHash := chainhash.Hash(msg.ChainHash)
|
||||||
|
req := &lnwallet.InitFundingReserveMsg{
|
||||||
|
ChainHash: &chainHash,
|
||||||
|
PendingChanID: msg.PendingChannelID,
|
||||||
|
NodeID: peer.IdentityKey(),
|
||||||
|
NodeAddr: peer.Address(),
|
||||||
|
LocalFundingAmt: 0,
|
||||||
|
RemoteFundingAmt: amt,
|
||||||
|
CommitFeePerKw: chainfee.SatPerKWeight(msg.FeePerKiloWeight),
|
||||||
|
FundingFeePerKw: 0,
|
||||||
|
PushMSat: msg.PushAmount,
|
||||||
|
Flags: msg.ChannelFlags,
|
||||||
|
MinConfs: 1,
|
||||||
|
CommitType: commitType,
|
||||||
|
}
|
||||||
|
|
||||||
|
reservation, err := f.cfg.Wallet.InitChannelReservation(req)
|
||||||
|
if err != nil {
|
||||||
|
log.Errorf("Unable to initialize reservation: %v", err)
|
||||||
|
f.failFundingFlow(peer, msg.PendingChannelID, err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// As we're the responder, we get to specify the number of confirmations
|
||||||
|
// that we require before both of us consider the channel open. We'll
|
||||||
|
// use our mapping to derive the proper number of confirmations based on
|
||||||
|
// the amount of the channel, and also if any funds are being pushed to
|
||||||
|
// us. If a depth value was set by our channel acceptor, we will use
|
||||||
|
// that value instead.
|
||||||
|
numConfsReq := f.cfg.NumRequiredConfs(msg.FundingAmount, msg.PushAmount)
|
||||||
|
if acceptorResp.MinAcceptDepth != 0 {
|
||||||
|
numConfsReq = acceptorResp.MinAcceptDepth
|
||||||
|
}
|
||||||
|
reservation.SetNumConfsRequired(numConfsReq)
|
||||||
|
|
||||||
|
// We'll also validate and apply all the constraints the initiating
|
||||||
|
// party is attempting to dictate for our commitment transaction.
|
||||||
|
channelConstraints := &channeldb.ChannelConstraints{
|
||||||
|
DustLimit: msg.DustLimit,
|
||||||
|
ChanReserve: msg.ChannelReserve,
|
||||||
|
MaxPendingAmount: msg.MaxValueInFlight,
|
||||||
|
MinHTLC: msg.HtlcMinimum,
|
||||||
|
MaxAcceptedHtlcs: msg.MaxAcceptedHTLCs,
|
||||||
|
CsvDelay: msg.CsvDelay,
|
||||||
|
}
|
||||||
|
err = reservation.CommitConstraints(
|
||||||
|
channelConstraints, f.cfg.MaxLocalCSVDelay,
|
||||||
|
)
|
||||||
|
if err != nil {
|
||||||
|
log.Errorf("Unacceptable channel constraints: %v", err)
|
||||||
|
f.failFundingFlow(peer, msg.PendingChannelID, err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// Check whether the peer supports upfront shutdown, and get a new wallet
|
||||||
|
// address if our node is configured to set shutdown addresses by default.
|
||||||
|
// We use the upfront shutdown script provided by our channel acceptor
|
||||||
|
// (if any) in lieu of user input.
|
||||||
|
shutdown, err := getUpfrontShutdownScript(
|
||||||
|
f.cfg.EnableUpfrontShutdown, peer, acceptorResp.UpfrontShutdown,
|
||||||
|
func() (lnwire.DeliveryAddress, error) {
|
||||||
|
addr, err := f.cfg.Wallet.NewAddress(lnwallet.WitnessPubKey, false)
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
return txscript.PayToAddrScript(addr)
|
||||||
|
},
|
||||||
|
)
|
||||||
|
if err != nil {
|
||||||
|
f.failFundingFlow(
|
||||||
|
peer, msg.PendingChannelID,
|
||||||
|
fmt.Errorf("getUpfrontShutdownScript error: %v", err),
|
||||||
|
)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
reservation.SetOurUpfrontShutdown(shutdown)
|
||||||
|
|
||||||
|
log.Infof("Requiring %v confirmations for pendingChan(%x): "+
|
||||||
|
"amt=%v, push_amt=%v, committype=%v, upfrontShutdown=%x", numConfsReq,
|
||||||
|
msg.PendingChannelID, amt, msg.PushAmount,
|
||||||
|
commitType, msg.UpfrontShutdownScript)
|
||||||
|
|
||||||
|
// Generate our required constraints for the remote party, using the
|
||||||
|
// values provided by the channel acceptor if they are non-zero.
|
||||||
|
remoteCsvDelay := f.cfg.RequiredRemoteDelay(amt)
|
||||||
|
if acceptorResp.CSVDelay != 0 {
|
||||||
|
remoteCsvDelay = acceptorResp.CSVDelay
|
||||||
|
}
|
||||||
|
|
||||||
|
chanReserve := f.cfg.RequiredRemoteChanReserve(amt, msg.DustLimit)
|
||||||
|
if acceptorResp.Reserve != 0 {
|
||||||
|
chanReserve = acceptorResp.Reserve
|
||||||
|
}
|
||||||
|
|
||||||
|
remoteMaxValue := f.cfg.RequiredRemoteMaxValue(amt)
|
||||||
|
if acceptorResp.InFlightTotal != 0 {
|
||||||
|
remoteMaxValue = acceptorResp.InFlightTotal
|
||||||
|
}
|
||||||
|
|
||||||
|
maxHtlcs := f.cfg.RequiredRemoteMaxHTLCs(amt)
|
||||||
|
if acceptorResp.HtlcLimit != 0 {
|
||||||
|
maxHtlcs = acceptorResp.HtlcLimit
|
||||||
|
}
|
||||||
|
|
||||||
|
// Default to our default minimum hltc value, replacing it with the
|
||||||
|
// channel acceptor's value if it is set.
|
||||||
|
minHtlc := f.cfg.DefaultMinHtlcIn
|
||||||
|
if acceptorResp.MinHtlcIn != 0 {
|
||||||
|
minHtlc = acceptorResp.MinHtlcIn
|
||||||
|
}
|
||||||
|
|
||||||
|
// Once the reservation has been created successfully, we add it to
|
||||||
|
// this peer's map of pending reservations to track this particular
|
||||||
|
// reservation until either abort or completion.
|
||||||
|
f.resMtx.Lock()
|
||||||
|
if _, ok := f.activeReservations[peerIDKey]; !ok {
|
||||||
|
f.activeReservations[peerIDKey] = make(pendingChannels)
|
||||||
|
}
|
||||||
|
resCtx := &reservationWithCtx{
|
||||||
|
reservation: reservation,
|
||||||
|
chanAmt: amt,
|
||||||
|
remoteCsvDelay: remoteCsvDelay,
|
||||||
|
remoteMinHtlc: minHtlc,
|
||||||
|
remoteMaxValue: remoteMaxValue,
|
||||||
|
remoteMaxHtlcs: maxHtlcs,
|
||||||
|
maxLocalCsv: f.cfg.MaxLocalCSVDelay,
|
||||||
|
err: make(chan error, 1),
|
||||||
|
peer: peer,
|
||||||
|
}
|
||||||
|
f.activeReservations[peerIDKey][msg.PendingChannelID] = resCtx
|
||||||
|
f.resMtx.Unlock()
|
||||||
|
|
||||||
|
// Update the timestamp once the fundingOpenMsg has been handled.
|
||||||
|
defer resCtx.updateTimestamp()
|
||||||
|
|
||||||
|
// With our parameters set, we'll now process their contribution so we
|
||||||
|
// can move the funding workflow ahead.
|
||||||
|
remoteContribution := &lnwallet.ChannelContribution{
|
||||||
|
FundingAmount: amt,
|
||||||
|
FirstCommitmentPoint: msg.FirstCommitmentPoint,
|
||||||
|
ChannelConfig: &channeldb.ChannelConfig{
|
||||||
|
ChannelConstraints: channeldb.ChannelConstraints{
|
||||||
|
DustLimit: msg.DustLimit,
|
||||||
|
MaxPendingAmount: remoteMaxValue,
|
||||||
|
ChanReserve: chanReserve,
|
||||||
|
MinHTLC: minHtlc,
|
||||||
|
MaxAcceptedHtlcs: maxHtlcs,
|
||||||
|
CsvDelay: remoteCsvDelay,
|
||||||
|
},
|
||||||
|
MultiSigKey: keychain.KeyDescriptor{
|
||||||
|
PubKey: copyPubKey(msg.FundingKey),
|
||||||
|
},
|
||||||
|
RevocationBasePoint: keychain.KeyDescriptor{
|
||||||
|
PubKey: copyPubKey(msg.RevocationPoint),
|
||||||
|
},
|
||||||
|
PaymentBasePoint: keychain.KeyDescriptor{
|
||||||
|
PubKey: copyPubKey(msg.PaymentPoint),
|
||||||
|
},
|
||||||
|
DelayBasePoint: keychain.KeyDescriptor{
|
||||||
|
PubKey: copyPubKey(msg.DelayedPaymentPoint),
|
||||||
|
},
|
||||||
|
HtlcBasePoint: keychain.KeyDescriptor{
|
||||||
|
PubKey: copyPubKey(msg.HtlcPoint),
|
||||||
|
},
|
||||||
|
},
|
||||||
|
UpfrontShutdown: msg.UpfrontShutdownScript,
|
||||||
|
}
|
||||||
|
err = reservation.ProcessSingleContribution(remoteContribution)
|
||||||
|
if err != nil {
|
||||||
|
log.Errorf("unable to add contribution reservation: %v", err)
|
||||||
|
f.failFundingFlow(peer, msg.PendingChannelID, err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
log.Infof("Sending fundingResp for pending_id(%x)",
|
||||||
|
msg.PendingChannelID)
|
||||||
|
log.Debugf("Remote party accepted commitment constraints: %v",
|
||||||
|
spew.Sdump(remoteContribution.ChannelConfig.ChannelConstraints))
|
||||||
|
|
||||||
|
// With the initiator's contribution recorded, respond with our
|
||||||
|
// contribution in the next message of the workflow.
|
||||||
|
ourContribution := reservation.OurContribution()
|
||||||
|
fundingAccept := lnwire.AcceptChannel{
|
||||||
|
PendingChannelID: msg.PendingChannelID,
|
||||||
|
DustLimit: ourContribution.DustLimit,
|
||||||
|
MaxValueInFlight: remoteMaxValue,
|
||||||
|
ChannelReserve: chanReserve,
|
||||||
|
MinAcceptDepth: uint32(numConfsReq),
|
||||||
|
HtlcMinimum: minHtlc,
|
||||||
|
CsvDelay: remoteCsvDelay,
|
||||||
|
MaxAcceptedHTLCs: maxHtlcs,
|
||||||
|
FundingKey: ourContribution.MultiSigKey.PubKey,
|
||||||
|
RevocationPoint: ourContribution.RevocationBasePoint.PubKey,
|
||||||
|
PaymentPoint: ourContribution.PaymentBasePoint.PubKey,
|
||||||
|
DelayedPaymentPoint: ourContribution.DelayBasePoint.PubKey,
|
||||||
|
HtlcPoint: ourContribution.HtlcBasePoint.PubKey,
|
||||||
|
FirstCommitmentPoint: ourContribution.FirstCommitmentPoint,
|
||||||
|
UpfrontShutdownScript: ourContribution.UpfrontShutdown,
|
||||||
|
}
|
||||||
|
|
||||||
|
if err := peer.SendMessage(true, &fundingAccept); err != nil {
|
||||||
|
log.Errorf("unable to send funding response to peer: %v", err)
|
||||||
|
f.failFundingFlow(peer, msg.PendingChannelID, err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// handleFundingAccept processes a response to the workflow initiation sent by
|
||||||
|
// the remote peer. This message then queues a message with the funding
|
||||||
|
// outpoint, and a commitment signature to the remote peer.
|
||||||
|
func (f *Manager) handleFundingAccept(peer lnpeer.Peer,
|
||||||
|
msg *lnwire.AcceptChannel) {
|
||||||
|
|
||||||
|
pendingChanID := msg.PendingChannelID
|
||||||
|
peerKey := peer.IdentityKey()
|
||||||
|
|
||||||
|
resCtx, err := f.getReservationCtx(peerKey, pendingChanID)
|
||||||
|
if err != nil {
|
||||||
|
log.Warnf("Can't find reservation (peerKey:%v, chan_id:%v)",
|
||||||
|
peerKey, pendingChanID)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// Update the timestamp once the fundingAcceptMsg has been handled.
|
||||||
|
defer resCtx.updateTimestamp()
|
||||||
|
|
||||||
|
log.Infof("Recv'd fundingResponse for pending_id(%x)",
|
||||||
|
pendingChanID[:])
|
||||||
|
|
||||||
|
// The required number of confirmations should not be greater than the
|
||||||
|
// maximum number of confirmations required by the ChainNotifier to
|
||||||
|
// properly dispatch confirmations.
|
||||||
|
if msg.MinAcceptDepth > chainntnfs.MaxNumConfs {
|
||||||
|
err := lnwallet.ErrNumConfsTooLarge(
|
||||||
|
msg.MinAcceptDepth, chainntnfs.MaxNumConfs,
|
||||||
|
)
|
||||||
|
log.Warnf("Unacceptable channel constraints: %v", err)
|
||||||
|
f.failFundingFlow(peer, msg.PendingChannelID, err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// We'll also specify the responder's preference for the number of
|
||||||
|
// required confirmations, and also the set of channel constraints
|
||||||
|
// they've specified for commitment states we can create.
|
||||||
|
resCtx.reservation.SetNumConfsRequired(uint16(msg.MinAcceptDepth))
|
||||||
|
channelConstraints := &channeldb.ChannelConstraints{
|
||||||
|
DustLimit: msg.DustLimit,
|
||||||
|
ChanReserve: msg.ChannelReserve,
|
||||||
|
MaxPendingAmount: msg.MaxValueInFlight,
|
||||||
|
MinHTLC: msg.HtlcMinimum,
|
||||||
|
MaxAcceptedHtlcs: msg.MaxAcceptedHTLCs,
|
||||||
|
CsvDelay: msg.CsvDelay,
|
||||||
|
}
|
||||||
|
err = resCtx.reservation.CommitConstraints(
|
||||||
|
channelConstraints, resCtx.maxLocalCsv,
|
||||||
|
)
|
||||||
|
if err != nil {
|
||||||
|
log.Warnf("Unacceptable channel constraints: %v", err)
|
||||||
|
f.failFundingFlow(peer, msg.PendingChannelID, err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// As they've accepted our channel constraints, we'll regenerate them
|
||||||
|
// here so we can properly commit their accepted constraints to the
|
||||||
|
// reservation.
|
||||||
|
chanReserve := f.cfg.RequiredRemoteChanReserve(resCtx.chanAmt, msg.DustLimit)
|
||||||
|
|
||||||
|
// The remote node has responded with their portion of the channel
|
||||||
|
// contribution. At this point, we can process their contribution which
|
||||||
|
// allows us to construct and sign both the commitment transaction, and
|
||||||
|
// the funding transaction.
|
||||||
|
remoteContribution := &lnwallet.ChannelContribution{
|
||||||
|
FirstCommitmentPoint: msg.FirstCommitmentPoint,
|
||||||
|
ChannelConfig: &channeldb.ChannelConfig{
|
||||||
|
ChannelConstraints: channeldb.ChannelConstraints{
|
||||||
|
DustLimit: msg.DustLimit,
|
||||||
|
MaxPendingAmount: resCtx.remoteMaxValue,
|
||||||
|
ChanReserve: chanReserve,
|
||||||
|
MinHTLC: resCtx.remoteMinHtlc,
|
||||||
|
MaxAcceptedHtlcs: resCtx.remoteMaxHtlcs,
|
||||||
|
CsvDelay: resCtx.remoteCsvDelay,
|
||||||
|
},
|
||||||
|
MultiSigKey: keychain.KeyDescriptor{
|
||||||
|
PubKey: copyPubKey(msg.FundingKey),
|
||||||
|
},
|
||||||
|
RevocationBasePoint: keychain.KeyDescriptor{
|
||||||
|
PubKey: copyPubKey(msg.RevocationPoint),
|
||||||
|
},
|
||||||
|
PaymentBasePoint: keychain.KeyDescriptor{
|
||||||
|
PubKey: copyPubKey(msg.PaymentPoint),
|
||||||
|
},
|
||||||
|
DelayBasePoint: keychain.KeyDescriptor{
|
||||||
|
PubKey: copyPubKey(msg.DelayedPaymentPoint),
|
||||||
|
},
|
||||||
|
HtlcBasePoint: keychain.KeyDescriptor{
|
||||||
|
PubKey: copyPubKey(msg.HtlcPoint),
|
||||||
|
},
|
||||||
|
},
|
||||||
|
UpfrontShutdown: msg.UpfrontShutdownScript,
|
||||||
|
}
|
||||||
|
err = resCtx.reservation.ProcessContribution(remoteContribution)
|
||||||
|
|
||||||
|
// The wallet has detected that a PSBT funding process was requested by
|
||||||
|
// the user and has halted the funding process after negotiating the
|
||||||
|
// multisig keys. We now have everything that is needed for the user to
|
||||||
|
// start constructing a PSBT that sends to the multisig funding address.
|
||||||
|
var psbtIntent *chanfunding.PsbtIntent
|
||||||
|
if psbtErr, ok := err.(*lnwallet.PsbtFundingRequired); ok {
|
||||||
|
// Return the information that is needed by the user to
|
||||||
|
// construct the PSBT back to the caller.
|
||||||
|
addr, amt, packet, err := psbtErr.Intent.FundingParams()
|
||||||
|
if err != nil {
|
||||||
|
log.Errorf("Unable to process PSBT funding params "+
|
||||||
|
"for contribution from %v: %v", peerKey, err)
|
||||||
|
f.failFundingFlow(peer, msg.PendingChannelID, err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
var buf bytes.Buffer
|
||||||
|
err = packet.Serialize(&buf)
|
||||||
|
if err != nil {
|
||||||
|
log.Errorf("Unable to serialize PSBT for "+
|
||||||
|
"contribution from %v: %v", peerKey, err)
|
||||||
|
f.failFundingFlow(peer, msg.PendingChannelID, err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
resCtx.updates <- &lnrpc.OpenStatusUpdate{
|
||||||
|
PendingChanId: pendingChanID[:],
|
||||||
|
Update: &lnrpc.OpenStatusUpdate_PsbtFund{
|
||||||
|
PsbtFund: &lnrpc.ReadyForPsbtFunding{
|
||||||
|
FundingAddress: addr.EncodeAddress(),
|
||||||
|
FundingAmount: amt,
|
||||||
|
Psbt: buf.Bytes(),
|
||||||
|
},
|
||||||
|
},
|
||||||
|
}
|
||||||
|
psbtIntent = psbtErr.Intent
|
||||||
|
} else if err != nil {
|
||||||
|
log.Errorf("Unable to process contribution from %v: %v",
|
||||||
|
peerKey, err)
|
||||||
|
f.failFundingFlow(peer, msg.PendingChannelID, err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
log.Infof("pendingChan(%x): remote party proposes num_confs=%v, "+
|
||||||
|
"csv_delay=%v", pendingChanID[:], msg.MinAcceptDepth, msg.CsvDelay)
|
||||||
|
log.Debugf("Remote party accepted commitment constraints: %v",
|
||||||
|
spew.Sdump(remoteContribution.ChannelConfig.ChannelConstraints))
|
||||||
|
|
||||||
|
// If the user requested funding through a PSBT, we cannot directly
|
||||||
|
// continue now and need to wait for the fully funded and signed PSBT
|
||||||
|
// to arrive. To not block any other channels from opening, we wait in
|
||||||
|
// a separate goroutine.
|
||||||
|
if psbtIntent != nil {
|
||||||
|
f.wg.Add(1)
|
||||||
|
go func() {
|
||||||
|
defer f.wg.Done()
|
||||||
|
f.waitForPsbt(psbtIntent, resCtx, pendingChanID)
|
||||||
|
}()
|
||||||
|
|
||||||
|
// With the new goroutine spawned, we can now exit to unblock
|
||||||
|
// the main event loop.
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// In a normal, non-PSBT funding flow, we can jump directly to the next
|
||||||
|
// step where we expect our contribution to be finalized.
|
||||||
|
f.continueFundingAccept(resCtx, pendingChanID)
|
||||||
|
}
|
||||||
|
|
||||||
|
// waitForPsbt blocks until either a signed PSBT arrives, an error occurs or
|
||||||
|
// the funding manager shuts down. In the case of a valid PSBT, the funding flow
|
||||||
|
// is continued.
|
||||||
|
//
|
||||||
|
// NOTE: This method must be called as a goroutine.
|
||||||
|
func (f *Manager) waitForPsbt(intent *chanfunding.PsbtIntent,
|
||||||
|
resCtx *reservationWithCtx, pendingChanID [32]byte) {
|
||||||
|
|
||||||
|
// failFlow is a helper that logs an error message with the current
|
||||||
|
// context and then fails the funding flow.
|
||||||
|
peerKey := resCtx.peer.IdentityKey()
|
||||||
|
failFlow := func(errMsg string, cause error) {
|
||||||
|
log.Errorf("Unable to handle funding accept message "+
|
||||||
|
"for peer_key=%x, pending_chan_id=%x: %s: %v",
|
||||||
|
peerKey.SerializeCompressed(), pendingChanID, errMsg,
|
||||||
|
cause)
|
||||||
|
f.failFundingFlow(resCtx.peer, pendingChanID, cause)
|
||||||
|
}
|
||||||
|
|
||||||
|
// We'll now wait until the intent has received the final and complete
|
||||||
|
// funding transaction. If the channel is closed without any error being
|
||||||
|
// sent, we know everything's going as expected.
|
||||||
|
select {
|
||||||
|
case err := <-intent.PsbtReady:
|
||||||
|
switch err {
|
||||||
|
// If the user canceled the funding reservation, we need to
|
||||||
|
// inform the other peer about us canceling the reservation.
|
||||||
|
case chanfunding.ErrUserCanceled:
|
||||||
|
failFlow("aborting PSBT flow", err)
|
||||||
|
return
|
||||||
|
|
||||||
|
// If the remote canceled the funding reservation, we don't need
|
||||||
|
// to send another fail message. But we want to inform the user
|
||||||
|
// about what happened.
|
||||||
|
case chanfunding.ErrRemoteCanceled:
|
||||||
|
log.Infof("Remote canceled, aborting PSBT flow "+
|
||||||
|
"for peer_key=%x, pending_chan_id=%x",
|
||||||
|
peerKey.SerializeCompressed(), pendingChanID)
|
||||||
|
return
|
||||||
|
|
||||||
|
// Nil error means the flow continues normally now.
|
||||||
|
case nil:
|
||||||
|
|
||||||
|
// For any other error, we'll fail the funding flow.
|
||||||
|
default:
|
||||||
|
failFlow("error waiting for PSBT flow", err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// A non-nil error means we can continue the funding flow.
|
||||||
|
// Notify the wallet so it can prepare everything we need to
|
||||||
|
// continue.
|
||||||
|
err = resCtx.reservation.ProcessPsbt()
|
||||||
|
if err != nil {
|
||||||
|
failFlow("error continuing PSBT flow", err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// We are now ready to continue the funding flow.
|
||||||
|
f.continueFundingAccept(resCtx, pendingChanID)
|
||||||
|
|
||||||
|
// Handle a server shutdown as well because the reservation won't
|
||||||
|
// survive a restart as it's in memory only.
|
||||||
|
case <-f.quit:
|
||||||
|
log.Errorf("Unable to handle funding accept message "+
|
||||||
|
"for peer_key=%x, pending_chan_id=%x: funding manager "+
|
||||||
|
"shutting down", peerKey.SerializeCompressed(),
|
||||||
|
pendingChanID)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// continueFundingAccept continues the channel funding flow once our
|
||||||
|
// contribution is finalized, the channel output is known and the funding
|
||||||
|
// transaction is signed.
|
||||||
|
func (f *Manager) continueFundingAccept(resCtx *reservationWithCtx,
|
||||||
|
pendingChanID [32]byte) {
|
||||||
|
|
||||||
|
// Now that we have their contribution, we can extract, then send over
|
||||||
|
// both the funding out point and our signature for their version of
|
||||||
|
// the commitment transaction to the remote peer.
|
||||||
|
outPoint := resCtx.reservation.FundingOutpoint()
|
||||||
|
_, sig := resCtx.reservation.OurSignatures()
|
||||||
|
|
||||||
|
// A new channel has almost finished the funding process. In order to
|
||||||
|
// properly synchronize with the writeHandler goroutine, we add a new
|
||||||
|
// channel to the barriers map which will be closed once the channel is
|
||||||
|
// fully open.
|
||||||
|
f.barrierMtx.Lock()
|
||||||
|
channelID := lnwire.NewChanIDFromOutPoint(outPoint)
|
||||||
|
log.Debugf("Creating chan barrier for ChanID(%v)", channelID)
|
||||||
|
f.newChanBarriers[channelID] = make(chan struct{})
|
||||||
|
f.barrierMtx.Unlock()
|
||||||
|
|
||||||
|
// The next message that advances the funding flow will reference the
|
||||||
|
// channel via its permanent channel ID, so we'll set up this mapping
|
||||||
|
// so we can retrieve the reservation context once we get the
|
||||||
|
// FundingSigned message.
|
||||||
|
f.resMtx.Lock()
|
||||||
|
f.signedReservations[channelID] = pendingChanID
|
||||||
|
f.resMtx.Unlock()
|
||||||
|
|
||||||
|
log.Infof("Generated ChannelPoint(%v) for pending_id(%x)", outPoint,
|
||||||
|
pendingChanID[:])
|
||||||
|
|
||||||
|
var err error
|
||||||
|
fundingCreated := &lnwire.FundingCreated{
|
||||||
|
PendingChannelID: pendingChanID,
|
||||||
|
FundingPoint: *outPoint,
|
||||||
|
}
|
||||||
|
fundingCreated.CommitSig, err = lnwire.NewSigFromSignature(sig)
|
||||||
|
if err != nil {
|
||||||
|
log.Errorf("Unable to parse signature: %v", err)
|
||||||
|
f.failFundingFlow(resCtx.peer, pendingChanID, err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
if err := resCtx.peer.SendMessage(true, fundingCreated); err != nil {
|
||||||
|
log.Errorf("Unable to send funding complete message: %v", err)
|
||||||
|
f.failFundingFlow(resCtx.peer, pendingChanID, err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// handleFundingCreated progresses the funding workflow when the daemon is on
|
||||||
|
// the responding side of a single funder workflow. Once this message has been
|
||||||
|
// processed, a signature is sent to the remote peer allowing it to broadcast
|
||||||
|
// the funding transaction, progressing the workflow into the final stage.
|
||||||
|
func (f *Manager) handleFundingCreated(peer lnpeer.Peer,
|
||||||
|
msg *lnwire.FundingCreated) {
|
||||||
|
|
||||||
|
peerKey := peer.IdentityKey()
|
||||||
|
pendingChanID := msg.PendingChannelID
|
||||||
|
|
||||||
|
resCtx, err := f.getReservationCtx(peerKey, pendingChanID)
|
||||||
|
if err != nil {
|
||||||
|
log.Warnf("can't find reservation (peer_id:%v, chan_id:%x)",
|
||||||
|
peerKey, pendingChanID[:])
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// The channel initiator has responded with the funding outpoint of the
|
||||||
|
// final funding transaction, as well as a signature for our version of
|
||||||
|
// the commitment transaction. So at this point, we can validate the
|
||||||
|
// initiator's commitment transaction, then send our own if it's valid.
|
||||||
|
// TODO(roasbeef): make case (p vs P) consistent throughout
|
||||||
|
fundingOut := msg.FundingPoint
|
||||||
|
log.Infof("completing pending_id(%x) with ChannelPoint(%v)",
|
||||||
|
pendingChanID[:], fundingOut)
|
||||||
|
|
||||||
|
commitSig, err := msg.CommitSig.ToSignature()
|
||||||
|
if err != nil {
|
||||||
|
log.Errorf("unable to parse signature: %v", err)
|
||||||
|
f.failFundingFlow(peer, pendingChanID, err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// With all the necessary data available, attempt to advance the
|
||||||
|
// funding workflow to the next stage. If this succeeds then the
|
||||||
|
// funding transaction will broadcast after our next message.
|
||||||
|
// CompleteReservationSingle will also mark the channel as 'IsPending'
|
||||||
|
// in the database.
|
||||||
|
completeChan, err := resCtx.reservation.CompleteReservationSingle(
|
||||||
|
&fundingOut, commitSig,
|
||||||
|
)
|
||||||
|
if err != nil {
|
||||||
|
// TODO(roasbeef): better error logging: peerID, channelID, etc.
|
||||||
|
log.Errorf("unable to complete single reservation: %v", err)
|
||||||
|
f.failFundingFlow(peer, pendingChanID, err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// The channel is marked IsPending in the database, and can be removed
|
||||||
|
// from the set of active reservations.
|
||||||
|
f.deleteReservationCtx(peerKey, msg.PendingChannelID)
|
||||||
|
|
||||||
|
// If something goes wrong before the funding transaction is confirmed,
|
||||||
|
// we use this convenience method to delete the pending OpenChannel
|
||||||
|
// from the database.
|
||||||
|
deleteFromDatabase := func() {
|
||||||
|
localBalance := completeChan.LocalCommitment.LocalBalance.ToSatoshis()
|
||||||
|
closeInfo := &channeldb.ChannelCloseSummary{
|
||||||
|
ChanPoint: completeChan.FundingOutpoint,
|
||||||
|
ChainHash: completeChan.ChainHash,
|
||||||
|
RemotePub: completeChan.IdentityPub,
|
||||||
|
CloseType: channeldb.FundingCanceled,
|
||||||
|
Capacity: completeChan.Capacity,
|
||||||
|
SettledBalance: localBalance,
|
||||||
|
RemoteCurrentRevocation: completeChan.RemoteCurrentRevocation,
|
||||||
|
RemoteNextRevocation: completeChan.RemoteNextRevocation,
|
||||||
|
LocalChanConfig: completeChan.LocalChanCfg,
|
||||||
|
}
|
||||||
|
|
||||||
|
// Close the channel with us as the initiator because we are
|
||||||
|
// deciding to exit the funding flow due to an internal error.
|
||||||
|
if err := completeChan.CloseChannel(
|
||||||
|
closeInfo, channeldb.ChanStatusLocalCloseInitiator,
|
||||||
|
); err != nil {
|
||||||
|
log.Errorf("Failed closing channel %v: %v",
|
||||||
|
completeChan.FundingOutpoint, err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// A new channel has almost finished the funding process. In order to
|
||||||
|
// properly synchronize with the writeHandler goroutine, we add a new
|
||||||
|
// channel to the barriers map which will be closed once the channel is
|
||||||
|
// fully open.
|
||||||
|
f.barrierMtx.Lock()
|
||||||
|
channelID := lnwire.NewChanIDFromOutPoint(&fundingOut)
|
||||||
|
log.Debugf("Creating chan barrier for ChanID(%v)", channelID)
|
||||||
|
f.newChanBarriers[channelID] = make(chan struct{})
|
||||||
|
f.barrierMtx.Unlock()
|
||||||
|
|
||||||
|
log.Infof("sending FundingSigned for pending_id(%x) over "+
|
||||||
|
"ChannelPoint(%v)", pendingChanID[:], fundingOut)
|
||||||
|
|
||||||
|
// With their signature for our version of the commitment transaction
|
||||||
|
// verified, we can now send over our signature to the remote peer.
|
||||||
|
_, sig := resCtx.reservation.OurSignatures()
|
||||||
|
ourCommitSig, err := lnwire.NewSigFromSignature(sig)
|
||||||
|
if err != nil {
|
||||||
|
log.Errorf("unable to parse signature: %v", err)
|
||||||
|
f.failFundingFlow(peer, pendingChanID, err)
|
||||||
|
deleteFromDatabase()
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
fundingSigned := &lnwire.FundingSigned{
|
||||||
|
ChanID: channelID,
|
||||||
|
CommitSig: ourCommitSig,
|
||||||
|
}
|
||||||
|
if err := peer.SendMessage(true, fundingSigned); err != nil {
|
||||||
|
log.Errorf("unable to send FundingSigned message: %v", err)
|
||||||
|
f.failFundingFlow(peer, pendingChanID, err)
|
||||||
|
deleteFromDatabase()
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// Now that we've sent over our final signature for this channel, we'll
|
||||||
|
// send it to the ChainArbitrator so it can watch for any on-chain
|
||||||
|
// actions during this final confirmation stage.
|
||||||
|
if err := f.cfg.WatchNewChannel(completeChan, peerKey); err != nil {
|
||||||
|
log.Errorf("Unable to send new ChannelPoint(%v) for "+
|
||||||
|
"arbitration: %v", fundingOut, err)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Create an entry in the local discovery map so we can ensure that we
|
||||||
|
// process the channel confirmation fully before we receive a funding
|
||||||
|
// locked message.
|
||||||
|
f.localDiscoveryMtx.Lock()
|
||||||
|
f.localDiscoverySignals[channelID] = make(chan struct{})
|
||||||
|
f.localDiscoveryMtx.Unlock()
|
||||||
|
|
||||||
|
// Inform the ChannelNotifier that the channel has entered
|
||||||
|
// pending open state.
|
||||||
|
f.cfg.NotifyPendingOpenChannelEvent(fundingOut, completeChan)
|
||||||
|
|
||||||
|
// At this point we have sent our last funding message to the
|
||||||
|
// initiating peer before the funding transaction will be broadcast.
|
||||||
|
// With this last message, our job as the responder is now complete.
|
||||||
|
// We'll wait for the funding transaction to reach the specified number
|
||||||
|
// of confirmations, then start normal operations.
|
||||||
|
//
|
||||||
|
// When we get to this point we have sent the signComplete message to
|
||||||
|
// the channel funder, and BOLT#2 specifies that we MUST remember the
|
||||||
|
// channel for reconnection. The channel is already marked
|
||||||
|
// as pending in the database, so in case of a disconnect or restart,
|
||||||
|
// we will continue waiting for the confirmation the next time we start
|
||||||
|
// the funding manager. In case the funding transaction never appears
|
||||||
|
// on the blockchain, we must forget this channel. We therefore
|
||||||
|
// completely forget about this channel if we haven't seen the funding
|
||||||
|
// transaction in 288 blocks (~ 48 hrs), by canceling the reservation
|
||||||
|
// and canceling the wait for the funding confirmation.
|
||||||
|
f.wg.Add(1)
|
||||||
|
go f.advanceFundingState(completeChan, pendingChanID, nil)
|
||||||
|
}
|
||||||
|
|
||||||
|
// handleFundingSigned processes the final message received in a single funder
|
||||||
|
// workflow. Once this message is processed, the funding transaction is
|
||||||
|
// broadcast. Once the funding transaction reaches a sufficient number of
|
||||||
|
// confirmations, a message is sent to the responding peer along with a compact
|
||||||
|
// encoding of the location of the channel within the blockchain.
|
||||||
|
func (f *Manager) handleFundingSigned(peer lnpeer.Peer,
|
||||||
|
msg *lnwire.FundingSigned) {
|
||||||
|
|
||||||
|
// As the funding signed message will reference the reservation by its
|
||||||
|
// permanent channel ID, we'll need to perform an intermediate look up
|
||||||
|
// before we can obtain the reservation.
|
||||||
|
f.resMtx.Lock()
|
||||||
|
pendingChanID, ok := f.signedReservations[msg.ChanID]
|
||||||
|
delete(f.signedReservations, msg.ChanID)
|
||||||
|
f.resMtx.Unlock()
|
||||||
|
if !ok {
|
||||||
|
err := fmt.Errorf("unable to find signed reservation for "+
|
||||||
|
"chan_id=%x", msg.ChanID)
|
||||||
|
log.Warnf(err.Error())
|
||||||
|
f.failFundingFlow(peer, msg.ChanID, err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
peerKey := peer.IdentityKey()
|
||||||
|
resCtx, err := f.getReservationCtx(peerKey, pendingChanID)
|
||||||
|
if err != nil {
|
||||||
|
log.Warnf("Unable to find reservation (peer_id:%v, "+
|
||||||
|
"chan_id:%x)", peerKey, pendingChanID[:])
|
||||||
|
// TODO: add ErrChanNotFound?
|
||||||
|
f.failFundingFlow(peer, pendingChanID, err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// Create an entry in the local discovery map so we can ensure that we
|
||||||
|
// process the channel confirmation fully before we receive a funding
|
||||||
|
// locked message.
|
||||||
|
fundingPoint := resCtx.reservation.FundingOutpoint()
|
||||||
|
permChanID := lnwire.NewChanIDFromOutPoint(fundingPoint)
|
||||||
|
f.localDiscoveryMtx.Lock()
|
||||||
|
f.localDiscoverySignals[permChanID] = make(chan struct{})
|
||||||
|
f.localDiscoveryMtx.Unlock()
|
||||||
|
|
||||||
|
// The remote peer has responded with a signature for our commitment
|
||||||
|
// transaction. We'll verify the signature for validity, then commit
|
||||||
|
// the state to disk as we can now open the channel.
|
||||||
|
commitSig, err := msg.CommitSig.ToSignature()
|
||||||
|
if err != nil {
|
||||||
|
log.Errorf("Unable to parse signature: %v", err)
|
||||||
|
f.failFundingFlow(peer, pendingChanID, err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
completeChan, err := resCtx.reservation.CompleteReservation(
|
||||||
|
nil, commitSig,
|
||||||
|
)
|
||||||
|
if err != nil {
|
||||||
|
log.Errorf("Unable to complete reservation sign "+
|
||||||
|
"complete: %v", err)
|
||||||
|
f.failFundingFlow(peer, pendingChanID, err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// The channel is now marked IsPending in the database, and we can
|
||||||
|
// delete it from our set of active reservations.
|
||||||
|
f.deleteReservationCtx(peerKey, pendingChanID)
|
||||||
|
|
||||||
|
// Broadcast the finalized funding transaction to the network, but only
|
||||||
|
// if we actually have the funding transaction.
|
||||||
|
if completeChan.ChanType.HasFundingTx() {
|
||||||
|
fundingTx := completeChan.FundingTxn
|
||||||
|
var fundingTxBuf bytes.Buffer
|
||||||
|
if err := fundingTx.Serialize(&fundingTxBuf); err != nil {
|
||||||
|
log.Errorf("Unable to serialize funding "+
|
||||||
|
"transaction %v: %v", fundingTx.TxHash(), err)
|
||||||
|
|
||||||
|
// Clear the buffer of any bytes that were written
|
||||||
|
// before the serialization error to prevent logging an
|
||||||
|
// incomplete transaction.
|
||||||
|
fundingTxBuf.Reset()
|
||||||
|
}
|
||||||
|
|
||||||
|
log.Infof("Broadcasting funding tx for ChannelPoint(%v): %x",
|
||||||
|
completeChan.FundingOutpoint, fundingTxBuf.Bytes())
|
||||||
|
|
||||||
|
// Set a nil short channel ID at this stage because we do not
|
||||||
|
// know it until our funding tx confirms.
|
||||||
|
label := labels.MakeLabel(
|
||||||
|
labels.LabelTypeChannelOpen, nil,
|
||||||
|
)
|
||||||
|
|
||||||
|
err = f.cfg.PublishTransaction(fundingTx, label)
|
||||||
|
if err != nil {
|
||||||
|
log.Errorf("Unable to broadcast funding tx %x for "+
|
||||||
|
"ChannelPoint(%v): %v", fundingTxBuf.Bytes(),
|
||||||
|
completeChan.FundingOutpoint, err)
|
||||||
|
|
||||||
|
// We failed to broadcast the funding transaction, but
|
||||||
|
// watch the channel regardless, in case the
|
||||||
|
// transaction made it to the network. We will retry
|
||||||
|
// broadcast at startup.
|
||||||
|
//
|
||||||
|
// TODO(halseth): retry more often? Handle with CPFP?
|
||||||
|
// Just delete from the DB?
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Now that we have a finalized reservation for this funding flow,
|
||||||
|
// we'll send the to be active channel to the ChainArbitrator so it can
|
||||||
|
// watch for any on-chain actions before the channel has fully
|
||||||
|
// confirmed.
|
||||||
|
if err := f.cfg.WatchNewChannel(completeChan, peerKey); err != nil {
|
||||||
|
log.Errorf("Unable to send new ChannelPoint(%v) for "+
|
||||||
|
"arbitration: %v", fundingPoint, err)
|
||||||
|
}
|
||||||
|
|
||||||
|
log.Infof("Finalizing pending_id(%x) over ChannelPoint(%v), "+
|
||||||
|
"waiting for channel open on-chain", pendingChanID[:],
|
||||||
|
fundingPoint)
|
||||||
|
|
||||||
|
// Send an update to the upstream client that the negotiation process
|
||||||
|
// is over.
|
||||||
|
//
|
||||||
|
// TODO(roasbeef): add abstraction over updates to accommodate
|
||||||
|
// long-polling, or SSE, etc.
|
||||||
|
upd := &lnrpc.OpenStatusUpdate{
|
||||||
|
Update: &lnrpc.OpenStatusUpdate_ChanPending{
|
||||||
|
ChanPending: &lnrpc.PendingUpdate{
|
||||||
|
Txid: fundingPoint.Hash[:],
|
||||||
|
OutputIndex: fundingPoint.Index,
|
||||||
|
},
|
||||||
|
},
|
||||||
|
PendingChanId: pendingChanID[:],
|
||||||
|
}
|
||||||
|
|
||||||
|
select {
|
||||||
|
case resCtx.updates <- upd:
|
||||||
|
// Inform the ChannelNotifier that the channel has entered
|
||||||
|
// pending open state.
|
||||||
|
f.cfg.NotifyPendingOpenChannelEvent(*fundingPoint, completeChan)
|
||||||
|
case <-f.quit:
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// At this point we have broadcast the funding transaction and done all
|
||||||
|
// necessary processing.
|
||||||
|
f.wg.Add(1)
|
||||||
|
go f.advanceFundingState(completeChan, pendingChanID, resCtx.updates)
|
||||||
|
}
|
||||||
|
|
||||||
|
// confirmedChannel wraps a confirmed funding transaction, as well as the short
|
||||||
|
// channel ID which identifies that channel into a single struct. We'll use
|
||||||
|
// this to pass around the final state of a channel after it has been
|
||||||
|
// confirmed.
|
||||||
|
type confirmedChannel struct {
|
||||||
|
// shortChanID expresses where in the block the funding transaction was
|
||||||
|
// located.
|
||||||
|
shortChanID lnwire.ShortChannelID
|
||||||
|
|
||||||
|
// fundingTx is the funding transaction that created the channel.
|
||||||
|
fundingTx *wire.MsgTx
|
||||||
|
}
|
||||||
|
|
||||||
|
// waitForFundingWithTimeout is a wrapper around waitForFundingConfirmation and
|
||||||
|
// waitForTimeout that will return ErrConfirmationTimeout if we are not the
|
||||||
|
// channel initiator and the maxWaitNumBlocksFundingConf has passed from the
|
||||||
|
// funding broadcast height. In case of confirmation, the short channel ID of
|
||||||
|
// the channel and the funding transaction will be returned.
|
||||||
|
func (f *Manager) waitForFundingWithTimeout(
|
||||||
|
ch *channeldb.OpenChannel) (*confirmedChannel, error) {
|
||||||
|
|
||||||
|
confChan := make(chan *confirmedChannel)
|
||||||
|
timeoutChan := make(chan error, 1)
|
||||||
|
cancelChan := make(chan struct{})
|
||||||
|
|
||||||
|
f.wg.Add(1)
|
||||||
|
go f.waitForFundingConfirmation(ch, cancelChan, confChan)
|
||||||
|
|
||||||
|
// If we are not the initiator, we have no money at stake and will
|
||||||
|
// timeout waiting for the funding transaction to confirm after a
|
||||||
|
// while.
|
||||||
|
if !ch.IsInitiator {
|
||||||
|
f.wg.Add(1)
|
||||||
|
go f.waitForTimeout(ch, cancelChan, timeoutChan)
|
||||||
|
}
|
||||||
|
defer close(cancelChan)
|
||||||
|
|
||||||
|
select {
|
||||||
|
case err := <-timeoutChan:
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
return nil, ErrConfirmationTimeout
|
||||||
|
|
||||||
|
case <-f.quit:
|
||||||
|
// The fundingManager is shutting down, and will resume wait on
|
||||||
|
// startup.
|
||||||
|
return nil, ErrFundingManagerShuttingDown
|
||||||
|
|
||||||
|
case confirmedChannel, ok := <-confChan:
|
||||||
|
if !ok {
|
||||||
|
return nil, fmt.Errorf("waiting for funding" +
|
||||||
|
"confirmation failed")
|
||||||
|
}
|
||||||
|
return confirmedChannel, nil
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// makeFundingScript re-creates the funding script for the funding transaction
|
||||||
|
// of the target channel.
|
||||||
|
func makeFundingScript(channel *channeldb.OpenChannel) ([]byte, error) {
|
||||||
|
localKey := channel.LocalChanCfg.MultiSigKey.PubKey.SerializeCompressed()
|
||||||
|
remoteKey := channel.RemoteChanCfg.MultiSigKey.PubKey.SerializeCompressed()
|
||||||
|
|
||||||
|
multiSigScript, err := input.GenMultiSigScript(localKey, remoteKey)
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
|
||||||
|
return input.WitnessScriptHash(multiSigScript)
|
||||||
|
}
|
||||||
|
|
||||||
|
// waitForFundingConfirmation handles the final stages of the channel funding
|
||||||
|
// process once the funding transaction has been broadcast. The primary
|
||||||
|
// function of waitForFundingConfirmation is to wait for blockchain
|
||||||
|
// confirmation, and then to notify the other systems that must be notified
|
||||||
|
// when a channel has become active for lightning transactions.
|
||||||
|
// The wait can be canceled by closing the cancelChan. In case of success,
|
||||||
|
// a *lnwire.ShortChannelID will be passed to confChan.
|
||||||
|
//
|
||||||
|
// NOTE: This MUST be run as a goroutine.
|
||||||
|
func (f *Manager) waitForFundingConfirmation(
|
||||||
|
completeChan *channeldb.OpenChannel, cancelChan <-chan struct{},
|
||||||
|
confChan chan<- *confirmedChannel) {
|
||||||
|
|
||||||
|
defer f.wg.Done()
|
||||||
|
defer close(confChan)
|
||||||
|
|
||||||
|
// Register with the ChainNotifier for a notification once the funding
|
||||||
|
// transaction reaches `numConfs` confirmations.
|
||||||
|
txid := completeChan.FundingOutpoint.Hash
|
||||||
|
fundingScript, err := makeFundingScript(completeChan)
|
||||||
|
if err != nil {
|
||||||
|
log.Errorf("unable to create funding script for "+
|
||||||
|
"ChannelPoint(%v): %v", completeChan.FundingOutpoint,
|
||||||
|
err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
numConfs := uint32(completeChan.NumConfsRequired)
|
||||||
|
confNtfn, err := f.cfg.Notifier.RegisterConfirmationsNtfn(
|
||||||
|
&txid, fundingScript, numConfs,
|
||||||
|
completeChan.FundingBroadcastHeight,
|
||||||
|
)
|
||||||
|
if err != nil {
|
||||||
|
log.Errorf("Unable to register for confirmation of "+
|
||||||
|
"ChannelPoint(%v): %v", completeChan.FundingOutpoint,
|
||||||
|
err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
log.Infof("Waiting for funding tx (%v) to reach %v confirmations",
|
||||||
|
txid, numConfs)
|
||||||
|
|
||||||
|
var confDetails *chainntnfs.TxConfirmation
|
||||||
|
var ok bool
|
||||||
|
|
||||||
|
// Wait until the specified number of confirmations has been reached,
|
||||||
|
// we get a cancel signal, or the wallet signals a shutdown.
|
||||||
|
select {
|
||||||
|
case confDetails, ok = <-confNtfn.Confirmed:
|
||||||
|
// fallthrough
|
||||||
|
|
||||||
|
case <-cancelChan:
|
||||||
|
log.Warnf("canceled waiting for funding confirmation, "+
|
||||||
|
"stopping funding flow for ChannelPoint(%v)",
|
||||||
|
completeChan.FundingOutpoint)
|
||||||
|
return
|
||||||
|
|
||||||
|
case <-f.quit:
|
||||||
|
log.Warnf("fundingManager shutting down, stopping funding "+
|
||||||
|
"flow for ChannelPoint(%v)",
|
||||||
|
completeChan.FundingOutpoint)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
if !ok {
|
||||||
|
log.Warnf("ChainNotifier shutting down, cannot complete "+
|
||||||
|
"funding flow for ChannelPoint(%v)",
|
||||||
|
completeChan.FundingOutpoint)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
fundingPoint := completeChan.FundingOutpoint
|
||||||
|
log.Infof("ChannelPoint(%v) is now active: ChannelID(%v)",
|
||||||
|
fundingPoint, lnwire.NewChanIDFromOutPoint(&fundingPoint))
|
||||||
|
|
||||||
|
// With the block height and the transaction index known, we can
|
||||||
|
// construct the compact chanID which is used on the network to unique
|
||||||
|
// identify channels.
|
||||||
|
shortChanID := lnwire.ShortChannelID{
|
||||||
|
BlockHeight: confDetails.BlockHeight,
|
||||||
|
TxIndex: confDetails.TxIndex,
|
||||||
|
TxPosition: uint16(fundingPoint.Index),
|
||||||
|
}
|
||||||
|
|
||||||
|
select {
|
||||||
|
case confChan <- &confirmedChannel{
|
||||||
|
shortChanID: shortChanID,
|
||||||
|
fundingTx: confDetails.Tx,
|
||||||
|
}:
|
||||||
|
case <-f.quit:
|
||||||
|
return
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// waitForTimeout will close the timeout channel if maxWaitNumBlocksFundingConf
|
||||||
|
// has passed from the broadcast height of the given channel. In case of error,
|
||||||
|
// the error is sent on timeoutChan. The wait can be canceled by closing the
|
||||||
|
// cancelChan.
|
||||||
|
//
|
||||||
|
// NOTE: timeoutChan MUST be buffered.
|
||||||
|
// NOTE: This MUST be run as a goroutine.
|
||||||
|
func (f *Manager) waitForTimeout(completeChan *channeldb.OpenChannel,
|
||||||
|
cancelChan <-chan struct{}, timeoutChan chan<- error) {
|
||||||
|
defer f.wg.Done()
|
||||||
|
|
||||||
|
epochClient, err := f.cfg.Notifier.RegisterBlockEpochNtfn(nil)
|
||||||
|
if err != nil {
|
||||||
|
timeoutChan <- fmt.Errorf("unable to register for epoch "+
|
||||||
|
"notification: %v", err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
defer epochClient.Cancel()
|
||||||
|
|
||||||
|
// On block maxHeight we will cancel the funding confirmation wait.
|
||||||
|
maxHeight := completeChan.FundingBroadcastHeight + maxWaitNumBlocksFundingConf
|
||||||
|
for {
|
||||||
|
select {
|
||||||
|
case epoch, ok := <-epochClient.Epochs:
|
||||||
|
if !ok {
|
||||||
|
timeoutChan <- fmt.Errorf("epoch client " +
|
||||||
|
"shutting down")
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// Close the timeout channel and exit if the block is
|
||||||
|
// aboce the max height.
|
||||||
|
if uint32(epoch.Height) >= maxHeight {
|
||||||
|
log.Warnf("Waited for %v blocks without "+
|
||||||
|
"seeing funding transaction confirmed,"+
|
||||||
|
" cancelling.",
|
||||||
|
maxWaitNumBlocksFundingConf)
|
||||||
|
|
||||||
|
// Notify the caller of the timeout.
|
||||||
|
close(timeoutChan)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// TODO: If we are the channel initiator implement
|
||||||
|
// a method for recovering the funds from the funding
|
||||||
|
// transaction
|
||||||
|
|
||||||
|
case <-cancelChan:
|
||||||
|
return
|
||||||
|
|
||||||
|
case <-f.quit:
|
||||||
|
// The fundingManager is shutting down, will resume
|
||||||
|
// waiting for the funding transaction on startup.
|
||||||
|
return
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// handleFundingConfirmation marks a channel as open in the database, and set
|
||||||
|
// the channelOpeningState markedOpen. In addition it will report the now
|
||||||
|
// decided short channel ID to the switch, and close the local discovery signal
|
||||||
|
// for this channel.
|
||||||
|
func (f *Manager) handleFundingConfirmation(
|
||||||
|
completeChan *channeldb.OpenChannel,
|
||||||
|
confChannel *confirmedChannel) error {
|
||||||
|
|
||||||
|
fundingPoint := completeChan.FundingOutpoint
|
||||||
|
chanID := lnwire.NewChanIDFromOutPoint(&fundingPoint)
|
||||||
|
|
||||||
|
// TODO(roasbeef): ideally persistent state update for chan above
|
||||||
|
// should be abstracted
|
||||||
|
|
||||||
|
// Now that that the channel has been fully confirmed, we'll request
|
||||||
|
// that the wallet fully verify this channel to ensure that it can be
|
||||||
|
// used.
|
||||||
|
err := f.cfg.Wallet.ValidateChannel(completeChan, confChannel.fundingTx)
|
||||||
|
if err != nil {
|
||||||
|
// TODO(roasbeef): delete chan state?
|
||||||
|
return fmt.Errorf("unable to validate channel: %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
// The funding transaction now being confirmed, we add this channel to
|
||||||
|
// the fundingManager's internal persistent state machine that we use
|
||||||
|
// to track the remaining process of the channel opening. This is
|
||||||
|
// useful to resume the opening process in case of restarts. We set the
|
||||||
|
// opening state before we mark the channel opened in the database,
|
||||||
|
// such that we can receover from one of the db writes failing.
|
||||||
|
err = f.saveChannelOpeningState(
|
||||||
|
&fundingPoint, markedOpen, &confChannel.shortChanID,
|
||||||
|
)
|
||||||
|
if err != nil {
|
||||||
|
return fmt.Errorf("error setting channel state to markedOpen: %v",
|
||||||
|
err)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Now that the channel has been fully confirmed and we successfully
|
||||||
|
// saved the opening state, we'll mark it as open within the database.
|
||||||
|
err = completeChan.MarkAsOpen(confChannel.shortChanID)
|
||||||
|
if err != nil {
|
||||||
|
return fmt.Errorf("error setting channel pending flag to false: "+
|
||||||
|
"%v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Inform the ChannelNotifier that the channel has transitioned from
|
||||||
|
// pending open to open.
|
||||||
|
f.cfg.NotifyOpenChannelEvent(completeChan.FundingOutpoint)
|
||||||
|
|
||||||
|
// As there might already be an active link in the switch with an
|
||||||
|
// outdated short chan ID, we'll instruct the switch to load the updated
|
||||||
|
// short chan id from disk.
|
||||||
|
err = f.cfg.ReportShortChanID(fundingPoint)
|
||||||
|
if err != nil {
|
||||||
|
log.Errorf("unable to report short chan id: %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
// If we opened the channel, and lnd's wallet published our funding tx
|
||||||
|
// (which is not the case for some channels) then we update our
|
||||||
|
// transaction label with our short channel ID, which is known now that
|
||||||
|
// our funding transaction has confirmed. We do not label transactions
|
||||||
|
// we did not publish, because our wallet has no knowledge of them.
|
||||||
|
if completeChan.IsInitiator && completeChan.ChanType.HasFundingTx() {
|
||||||
|
shortChanID := completeChan.ShortChanID()
|
||||||
|
label := labels.MakeLabel(
|
||||||
|
labels.LabelTypeChannelOpen, &shortChanID,
|
||||||
|
)
|
||||||
|
|
||||||
|
err = f.cfg.UpdateLabel(
|
||||||
|
completeChan.FundingOutpoint.Hash, label,
|
||||||
|
)
|
||||||
|
if err != nil {
|
||||||
|
log.Errorf("unable to update label: %v", err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Close the discoverySignal channel, indicating to a separate
|
||||||
|
// goroutine that the channel now is marked as open in the database
|
||||||
|
// and that it is acceptable to process funding locked messages
|
||||||
|
// from the peer.
|
||||||
|
f.localDiscoveryMtx.Lock()
|
||||||
|
if discoverySignal, ok := f.localDiscoverySignals[chanID]; ok {
|
||||||
|
close(discoverySignal)
|
||||||
|
}
|
||||||
|
f.localDiscoveryMtx.Unlock()
|
||||||
|
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// sendFundingLocked creates and sends the fundingLocked message.
|
||||||
|
// This should be called after the funding transaction has been confirmed,
|
||||||
|
// and the channelState is 'markedOpen'.
|
||||||
|
func (f *Manager) sendFundingLocked(
|
||||||
|
completeChan *channeldb.OpenChannel, channel *lnwallet.LightningChannel,
|
||||||
|
shortChanID *lnwire.ShortChannelID) error {
|
||||||
|
|
||||||
|
chanID := lnwire.NewChanIDFromOutPoint(&completeChan.FundingOutpoint)
|
||||||
|
|
||||||
|
var peerKey [33]byte
|
||||||
|
copy(peerKey[:], completeChan.IdentityPub.SerializeCompressed())
|
||||||
|
|
||||||
|
// Next, we'll send over the funding locked message which marks that we
|
||||||
|
// consider the channel open by presenting the remote party with our
|
||||||
|
// next revocation key. Without the revocation key, the remote party
|
||||||
|
// will be unable to propose state transitions.
|
||||||
|
nextRevocation, err := channel.NextRevocationKey()
|
||||||
|
if err != nil {
|
||||||
|
return fmt.Errorf("unable to create next revocation: %v", err)
|
||||||
|
}
|
||||||
|
fundingLockedMsg := lnwire.NewFundingLocked(chanID, nextRevocation)
|
||||||
|
|
||||||
|
// If the peer has disconnected before we reach this point, we will need
|
||||||
|
// to wait for him to come back online before sending the fundingLocked
|
||||||
|
// message. This is special for fundingLocked, since failing to send any
|
||||||
|
// of the previous messages in the funding flow just cancels the flow.
|
||||||
|
// But now the funding transaction is confirmed, the channel is open
|
||||||
|
// and we have to make sure the peer gets the fundingLocked message when
|
||||||
|
// it comes back online. This is also crucial during restart of lnd,
|
||||||
|
// where we might try to resend the fundingLocked message before the
|
||||||
|
// server has had the time to connect to the peer. We keep trying to
|
||||||
|
// send fundingLocked until we succeed, or the fundingManager is shut
|
||||||
|
// down.
|
||||||
|
for {
|
||||||
|
connected := make(chan lnpeer.Peer, 1)
|
||||||
|
f.cfg.NotifyWhenOnline(peerKey, connected)
|
||||||
|
|
||||||
|
var peer lnpeer.Peer
|
||||||
|
select {
|
||||||
|
case peer = <-connected:
|
||||||
|
case <-f.quit:
|
||||||
|
return ErrFundingManagerShuttingDown
|
||||||
|
}
|
||||||
|
|
||||||
|
log.Infof("Peer(%x) is online, sending FundingLocked "+
|
||||||
|
"for ChannelID(%v)", peerKey, chanID)
|
||||||
|
|
||||||
|
if err := peer.SendMessage(true, fundingLockedMsg); err == nil {
|
||||||
|
// Sending succeeded, we can break out and continue the
|
||||||
|
// funding flow.
|
||||||
|
break
|
||||||
|
}
|
||||||
|
|
||||||
|
log.Warnf("Unable to send fundingLocked to peer %x: %v. "+
|
||||||
|
"Will retry when online", peerKey, err)
|
||||||
|
}
|
||||||
|
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// addToRouterGraph sends a ChannelAnnouncement and a ChannelUpdate to the
|
||||||
|
// gossiper so that the channel is added to the Router's internal graph.
|
||||||
|
// These announcement messages are NOT broadcasted to the greater network,
|
||||||
|
// only to the channel counter party. The proofs required to announce the
|
||||||
|
// channel to the greater network will be created and sent in annAfterSixConfs.
|
||||||
|
func (f *Manager) addToRouterGraph(completeChan *channeldb.OpenChannel,
|
||||||
|
shortChanID *lnwire.ShortChannelID) error {
|
||||||
|
|
||||||
|
chanID := lnwire.NewChanIDFromOutPoint(&completeChan.FundingOutpoint)
|
||||||
|
|
||||||
|
// We'll obtain the min HTLC value we can forward in our direction, as
|
||||||
|
// we'll use this value within our ChannelUpdate. This constraint is
|
||||||
|
// originally set by the remote node, as it will be the one that will
|
||||||
|
// need to determine the smallest HTLC it deems economically relevant.
|
||||||
|
fwdMinHTLC := completeChan.LocalChanCfg.MinHTLC
|
||||||
|
|
||||||
|
// We don't necessarily want to go as low as the remote party
|
||||||
|
// allows. Check it against our default forwarding policy.
|
||||||
|
if fwdMinHTLC < f.cfg.DefaultRoutingPolicy.MinHTLCOut {
|
||||||
|
fwdMinHTLC = f.cfg.DefaultRoutingPolicy.MinHTLCOut
|
||||||
|
}
|
||||||
|
|
||||||
|
// We'll obtain the max HTLC value we can forward in our direction, as
|
||||||
|
// we'll use this value within our ChannelUpdate. This value must be <=
|
||||||
|
// channel capacity and <= the maximum in-flight msats set by the peer.
|
||||||
|
fwdMaxHTLC := completeChan.LocalChanCfg.MaxPendingAmount
|
||||||
|
capacityMSat := lnwire.NewMSatFromSatoshis(completeChan.Capacity)
|
||||||
|
if fwdMaxHTLC > capacityMSat {
|
||||||
|
fwdMaxHTLC = capacityMSat
|
||||||
|
}
|
||||||
|
|
||||||
|
ann, err := f.newChanAnnouncement(
|
||||||
|
f.cfg.IDKey, completeChan.IdentityPub,
|
||||||
|
completeChan.LocalChanCfg.MultiSigKey.PubKey,
|
||||||
|
completeChan.RemoteChanCfg.MultiSigKey.PubKey, *shortChanID,
|
||||||
|
chanID, fwdMinHTLC, fwdMaxHTLC,
|
||||||
|
)
|
||||||
|
if err != nil {
|
||||||
|
return fmt.Errorf("error generating channel "+
|
||||||
|
"announcement: %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Send ChannelAnnouncement and ChannelUpdate to the gossiper to add
|
||||||
|
// to the Router's topology.
|
||||||
|
errChan := f.cfg.SendAnnouncement(
|
||||||
|
ann.chanAnn, discovery.ChannelCapacity(completeChan.Capacity),
|
||||||
|
discovery.ChannelPoint(completeChan.FundingOutpoint),
|
||||||
|
)
|
||||||
|
select {
|
||||||
|
case err := <-errChan:
|
||||||
|
if err != nil {
|
||||||
|
if routing.IsError(err, routing.ErrOutdated,
|
||||||
|
routing.ErrIgnored) {
|
||||||
|
log.Debugf("Router rejected "+
|
||||||
|
"ChannelAnnouncement: %v", err)
|
||||||
|
} else {
|
||||||
|
return fmt.Errorf("error sending channel "+
|
||||||
|
"announcement: %v", err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
case <-f.quit:
|
||||||
|
return ErrFundingManagerShuttingDown
|
||||||
|
}
|
||||||
|
|
||||||
|
errChan = f.cfg.SendAnnouncement(ann.chanUpdateAnn)
|
||||||
|
select {
|
||||||
|
case err := <-errChan:
|
||||||
|
if err != nil {
|
||||||
|
if routing.IsError(err, routing.ErrOutdated,
|
||||||
|
routing.ErrIgnored) {
|
||||||
|
log.Debugf("Router rejected "+
|
||||||
|
"ChannelUpdate: %v", err)
|
||||||
|
} else {
|
||||||
|
return fmt.Errorf("error sending channel "+
|
||||||
|
"update: %v", err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
case <-f.quit:
|
||||||
|
return ErrFundingManagerShuttingDown
|
||||||
|
}
|
||||||
|
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// annAfterSixConfs broadcasts the necessary channel announcement messages to
|
||||||
|
// the network after 6 confs. Should be called after the fundingLocked message
|
||||||
|
// is sent and the channel is added to the router graph (channelState is
|
||||||
|
// 'addedToRouterGraph') and the channel is ready to be used. This is the last
|
||||||
|
// step in the channel opening process, and the opening state will be deleted
|
||||||
|
// from the database if successful.
|
||||||
|
func (f *Manager) annAfterSixConfs(completeChan *channeldb.OpenChannel,
|
||||||
|
shortChanID *lnwire.ShortChannelID) error {
|
||||||
|
|
||||||
|
// If this channel is not meant to be announced to the greater network,
|
||||||
|
// we'll only send our NodeAnnouncement to our counterparty to ensure we
|
||||||
|
// don't leak any of our information.
|
||||||
|
announceChan := completeChan.ChannelFlags&lnwire.FFAnnounceChannel != 0
|
||||||
|
if !announceChan {
|
||||||
|
log.Debugf("Will not announce private channel %v.",
|
||||||
|
shortChanID.ToUint64())
|
||||||
|
|
||||||
|
peerChan := make(chan lnpeer.Peer, 1)
|
||||||
|
|
||||||
|
var peerKey [33]byte
|
||||||
|
copy(peerKey[:], completeChan.IdentityPub.SerializeCompressed())
|
||||||
|
|
||||||
|
f.cfg.NotifyWhenOnline(peerKey, peerChan)
|
||||||
|
|
||||||
|
var peer lnpeer.Peer
|
||||||
|
select {
|
||||||
|
case peer = <-peerChan:
|
||||||
|
case <-f.quit:
|
||||||
|
return ErrFundingManagerShuttingDown
|
||||||
|
}
|
||||||
|
|
||||||
|
nodeAnn, err := f.cfg.CurrentNodeAnnouncement()
|
||||||
|
if err != nil {
|
||||||
|
return fmt.Errorf("unable to retrieve current node "+
|
||||||
|
"announcement: %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
chanID := lnwire.NewChanIDFromOutPoint(
|
||||||
|
&completeChan.FundingOutpoint,
|
||||||
|
)
|
||||||
|
pubKey := peer.PubKey()
|
||||||
|
log.Debugf("Sending our NodeAnnouncement for "+
|
||||||
|
"ChannelID(%v) to %x", chanID, pubKey)
|
||||||
|
|
||||||
|
// TODO(halseth): make reliable. If the peer is not online this
|
||||||
|
// will fail, and the opening process will stop. Should instead
|
||||||
|
// block here, waiting for the peer to come online.
|
||||||
|
if err := peer.SendMessage(true, &nodeAnn); err != nil {
|
||||||
|
return fmt.Errorf("unable to send node announcement "+
|
||||||
|
"to peer %x: %v", pubKey, err)
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
// Otherwise, we'll wait until the funding transaction has
|
||||||
|
// reached 6 confirmations before announcing it.
|
||||||
|
numConfs := uint32(completeChan.NumConfsRequired)
|
||||||
|
if numConfs < 6 {
|
||||||
|
numConfs = 6
|
||||||
|
}
|
||||||
|
txid := completeChan.FundingOutpoint.Hash
|
||||||
|
log.Debugf("Will announce channel %v after ChannelPoint"+
|
||||||
|
"(%v) has gotten %d confirmations",
|
||||||
|
shortChanID.ToUint64(), completeChan.FundingOutpoint,
|
||||||
|
numConfs)
|
||||||
|
|
||||||
|
fundingScript, err := makeFundingScript(completeChan)
|
||||||
|
if err != nil {
|
||||||
|
return fmt.Errorf("unable to create funding script for "+
|
||||||
|
"ChannelPoint(%v): %v",
|
||||||
|
completeChan.FundingOutpoint, err)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Register with the ChainNotifier for a notification once the
|
||||||
|
// funding transaction reaches at least 6 confirmations.
|
||||||
|
confNtfn, err := f.cfg.Notifier.RegisterConfirmationsNtfn(
|
||||||
|
&txid, fundingScript, numConfs,
|
||||||
|
completeChan.FundingBroadcastHeight,
|
||||||
|
)
|
||||||
|
if err != nil {
|
||||||
|
return fmt.Errorf("unable to register for "+
|
||||||
|
"confirmation of ChannelPoint(%v): %v",
|
||||||
|
completeChan.FundingOutpoint, err)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Wait until 6 confirmations has been reached or the wallet
|
||||||
|
// signals a shutdown.
|
||||||
|
select {
|
||||||
|
case _, ok := <-confNtfn.Confirmed:
|
||||||
|
if !ok {
|
||||||
|
return fmt.Errorf("ChainNotifier shutting "+
|
||||||
|
"down, cannot complete funding flow "+
|
||||||
|
"for ChannelPoint(%v)",
|
||||||
|
completeChan.FundingOutpoint)
|
||||||
|
}
|
||||||
|
// Fallthrough.
|
||||||
|
|
||||||
|
case <-f.quit:
|
||||||
|
return fmt.Errorf("%v, stopping funding flow for "+
|
||||||
|
"ChannelPoint(%v)",
|
||||||
|
ErrFundingManagerShuttingDown,
|
||||||
|
completeChan.FundingOutpoint)
|
||||||
|
}
|
||||||
|
|
||||||
|
fundingPoint := completeChan.FundingOutpoint
|
||||||
|
chanID := lnwire.NewChanIDFromOutPoint(&fundingPoint)
|
||||||
|
|
||||||
|
log.Infof("Announcing ChannelPoint(%v), short_chan_id=%v",
|
||||||
|
&fundingPoint, shortChanID)
|
||||||
|
|
||||||
|
// Create and broadcast the proofs required to make this channel
|
||||||
|
// public and usable for other nodes for routing.
|
||||||
|
err = f.announceChannel(
|
||||||
|
f.cfg.IDKey, completeChan.IdentityPub,
|
||||||
|
completeChan.LocalChanCfg.MultiSigKey.PubKey,
|
||||||
|
completeChan.RemoteChanCfg.MultiSigKey.PubKey,
|
||||||
|
*shortChanID, chanID,
|
||||||
|
)
|
||||||
|
if err != nil {
|
||||||
|
return fmt.Errorf("channel announcement failed: %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
log.Debugf("Channel with ChannelPoint(%v), short_chan_id=%v "+
|
||||||
|
"announced", &fundingPoint, shortChanID)
|
||||||
|
}
|
||||||
|
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// handleFundingLocked finalizes the channel funding process and enables the
|
||||||
|
// channel to enter normal operating mode.
|
||||||
|
func (f *Manager) handleFundingLocked(peer lnpeer.Peer,
|
||||||
|
msg *lnwire.FundingLocked) {
|
||||||
|
|
||||||
|
defer f.wg.Done()
|
||||||
|
log.Debugf("Received FundingLocked for ChannelID(%v) from "+
|
||||||
|
"peer %x", msg.ChanID,
|
||||||
|
peer.IdentityKey().SerializeCompressed())
|
||||||
|
|
||||||
|
// If we are currently in the process of handling a funding locked
|
||||||
|
// message for this channel, ignore.
|
||||||
|
f.handleFundingLockedMtx.Lock()
|
||||||
|
_, ok := f.handleFundingLockedBarriers[msg.ChanID]
|
||||||
|
if ok {
|
||||||
|
log.Infof("Already handling fundingLocked for "+
|
||||||
|
"ChannelID(%v), ignoring.", msg.ChanID)
|
||||||
|
f.handleFundingLockedMtx.Unlock()
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// If not already handling fundingLocked for this channel, set up
|
||||||
|
// barrier, and move on.
|
||||||
|
f.handleFundingLockedBarriers[msg.ChanID] = struct{}{}
|
||||||
|
f.handleFundingLockedMtx.Unlock()
|
||||||
|
|
||||||
|
defer func() {
|
||||||
|
f.handleFundingLockedMtx.Lock()
|
||||||
|
delete(f.handleFundingLockedBarriers, msg.ChanID)
|
||||||
|
f.handleFundingLockedMtx.Unlock()
|
||||||
|
}()
|
||||||
|
|
||||||
|
f.localDiscoveryMtx.Lock()
|
||||||
|
localDiscoverySignal, ok := f.localDiscoverySignals[msg.ChanID]
|
||||||
|
f.localDiscoveryMtx.Unlock()
|
||||||
|
|
||||||
|
if ok {
|
||||||
|
// Before we proceed with processing the funding locked
|
||||||
|
// message, we'll wait for the local waitForFundingConfirmation
|
||||||
|
// goroutine to signal that it has the necessary state in
|
||||||
|
// place. Otherwise, we may be missing critical information
|
||||||
|
// required to handle forwarded HTLC's.
|
||||||
|
select {
|
||||||
|
case <-localDiscoverySignal:
|
||||||
|
// Fallthrough
|
||||||
|
case <-f.quit:
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// With the signal received, we can now safely delete the entry
|
||||||
|
// from the map.
|
||||||
|
f.localDiscoveryMtx.Lock()
|
||||||
|
delete(f.localDiscoverySignals, msg.ChanID)
|
||||||
|
f.localDiscoveryMtx.Unlock()
|
||||||
|
}
|
||||||
|
|
||||||
|
// First, we'll attempt to locate the channel whose funding workflow is
|
||||||
|
// being finalized by this message. We go to the database rather than
|
||||||
|
// our reservation map as we may have restarted, mid funding flow.
|
||||||
|
chanID := msg.ChanID
|
||||||
|
channel, err := f.cfg.FindChannel(chanID)
|
||||||
|
if err != nil {
|
||||||
|
log.Errorf("Unable to locate ChannelID(%v), cannot complete "+
|
||||||
|
"funding", chanID)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// If the RemoteNextRevocation is non-nil, it means that we have
|
||||||
|
// already processed fundingLocked for this channel, so ignore.
|
||||||
|
if channel.RemoteNextRevocation != nil {
|
||||||
|
log.Infof("Received duplicate fundingLocked for "+
|
||||||
|
"ChannelID(%v), ignoring.", chanID)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// The funding locked message contains the next commitment point we'll
|
||||||
|
// need to create the next commitment state for the remote party. So
|
||||||
|
// we'll insert that into the channel now before passing it along to
|
||||||
|
// other sub-systems.
|
||||||
|
err = channel.InsertNextRevocation(msg.NextPerCommitmentPoint)
|
||||||
|
if err != nil {
|
||||||
|
log.Errorf("unable to insert next commitment point: %v", err)
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// Launch a defer so we _ensure_ that the channel barrier is properly
|
||||||
|
// closed even if the target peer is no longer online at this point.
|
||||||
|
defer func() {
|
||||||
|
// Close the active channel barrier signaling the readHandler
|
||||||
|
// that commitment related modifications to this channel can
|
||||||
|
// now proceed.
|
||||||
|
f.barrierMtx.Lock()
|
||||||
|
chanBarrier, ok := f.newChanBarriers[chanID]
|
||||||
|
if ok {
|
||||||
|
log.Tracef("Closing chan barrier for ChanID(%v)",
|
||||||
|
chanID)
|
||||||
|
close(chanBarrier)
|
||||||
|
delete(f.newChanBarriers, chanID)
|
||||||
|
}
|
||||||
|
f.barrierMtx.Unlock()
|
||||||
|
}()
|
||||||
|
|
||||||
|
if err := peer.AddNewChannel(channel, f.quit); err != nil {
|
||||||
|
log.Errorf("Unable to add new channel %v with peer %x: %v",
|
||||||
|
channel.FundingOutpoint,
|
||||||
|
peer.IdentityKey().SerializeCompressed(), err,
|
||||||
|
)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// chanAnnouncement encapsulates the two authenticated announcements that we
|
||||||
|
// send out to the network after a new channel has been created locally.
|
||||||
|
type chanAnnouncement struct {
|
||||||
|
chanAnn *lnwire.ChannelAnnouncement
|
||||||
|
chanUpdateAnn *lnwire.ChannelUpdate
|
||||||
|
chanProof *lnwire.AnnounceSignatures
|
||||||
|
}
|
||||||
|
|
||||||
|
// newChanAnnouncement creates the authenticated channel announcement messages
|
||||||
|
// required to broadcast a newly created channel to the network. The
|
||||||
|
// announcement is two part: the first part authenticates the existence of the
|
||||||
|
// channel and contains four signatures binding the funding pub keys and
|
||||||
|
// identity pub keys of both parties to the channel, and the second segment is
|
||||||
|
// authenticated only by us and contains our directional routing policy for the
|
||||||
|
// channel.
|
||||||
|
func (f *Manager) newChanAnnouncement(localPubKey, remotePubKey,
|
||||||
|
localFundingKey, remoteFundingKey *btcec.PublicKey,
|
||||||
|
shortChanID lnwire.ShortChannelID, chanID lnwire.ChannelID,
|
||||||
|
fwdMinHTLC, fwdMaxHTLC lnwire.MilliSatoshi) (*chanAnnouncement, error) {
|
||||||
|
|
||||||
|
chainHash := *f.cfg.Wallet.Cfg.NetParams.GenesisHash
|
||||||
|
|
||||||
|
// The unconditional section of the announcement is the ShortChannelID
|
||||||
|
// itself which compactly encodes the location of the funding output
|
||||||
|
// within the blockchain.
|
||||||
|
chanAnn := &lnwire.ChannelAnnouncement{
|
||||||
|
ShortChannelID: shortChanID,
|
||||||
|
Features: lnwire.NewRawFeatureVector(),
|
||||||
|
ChainHash: chainHash,
|
||||||
|
}
|
||||||
|
|
||||||
|
// The chanFlags field indicates which directed edge of the channel is
|
||||||
|
// being updated within the ChannelUpdateAnnouncement announcement
|
||||||
|
// below. A value of zero means it's the edge of the "first" node and 1
|
||||||
|
// being the other node.
|
||||||
|
var chanFlags lnwire.ChanUpdateChanFlags
|
||||||
|
|
||||||
|
// The lexicographical ordering of the two identity public keys of the
|
||||||
|
// nodes indicates which of the nodes is "first". If our serialized
|
||||||
|
// identity key is lower than theirs then we're the "first" node and
|
||||||
|
// second otherwise.
|
||||||
|
selfBytes := localPubKey.SerializeCompressed()
|
||||||
|
remoteBytes := remotePubKey.SerializeCompressed()
|
||||||
|
if bytes.Compare(selfBytes, remoteBytes) == -1 {
|
||||||
|
copy(chanAnn.NodeID1[:], localPubKey.SerializeCompressed())
|
||||||
|
copy(chanAnn.NodeID2[:], remotePubKey.SerializeCompressed())
|
||||||
|
copy(chanAnn.BitcoinKey1[:], localFundingKey.SerializeCompressed())
|
||||||
|
copy(chanAnn.BitcoinKey2[:], remoteFundingKey.SerializeCompressed())
|
||||||
|
|
||||||
|
// If we're the first node then update the chanFlags to
|
||||||
|
// indicate the "direction" of the update.
|
||||||
|
chanFlags = 0
|
||||||
|
} else {
|
||||||
|
copy(chanAnn.NodeID1[:], remotePubKey.SerializeCompressed())
|
||||||
|
copy(chanAnn.NodeID2[:], localPubKey.SerializeCompressed())
|
||||||
|
copy(chanAnn.BitcoinKey1[:], remoteFundingKey.SerializeCompressed())
|
||||||
|
copy(chanAnn.BitcoinKey2[:], localFundingKey.SerializeCompressed())
|
||||||
|
|
||||||
|
// If we're the second node then update the chanFlags to
|
||||||
|
// indicate the "direction" of the update.
|
||||||
|
chanFlags = 1
|
||||||
|
}
|
||||||
|
|
||||||
|
// Our channel update message flags will signal that we support the
|
||||||
|
// max_htlc field.
|
||||||
|
msgFlags := lnwire.ChanUpdateOptionMaxHtlc
|
||||||
|
|
||||||
|
// We announce the channel with the default values. Some of
|
||||||
|
// these values can later be changed by crafting a new ChannelUpdate.
|
||||||
|
chanUpdateAnn := &lnwire.ChannelUpdate{
|
||||||
|
ShortChannelID: shortChanID,
|
||||||
|
ChainHash: chainHash,
|
||||||
|
Timestamp: uint32(time.Now().Unix()),
|
||||||
|
MessageFlags: msgFlags,
|
||||||
|
ChannelFlags: chanFlags,
|
||||||
|
TimeLockDelta: uint16(f.cfg.DefaultRoutingPolicy.TimeLockDelta),
|
||||||
|
|
||||||
|
// We use the HtlcMinimumMsat that the remote party required us
|
||||||
|
// to use, as our ChannelUpdate will be used to carry HTLCs
|
||||||
|
// towards them.
|
||||||
|
HtlcMinimumMsat: fwdMinHTLC,
|
||||||
|
HtlcMaximumMsat: fwdMaxHTLC,
|
||||||
|
|
||||||
|
BaseFee: uint32(f.cfg.DefaultRoutingPolicy.BaseFee),
|
||||||
|
FeeRate: uint32(f.cfg.DefaultRoutingPolicy.FeeRate),
|
||||||
|
}
|
||||||
|
|
||||||
|
// With the channel update announcement constructed, we'll generate a
|
||||||
|
// signature that signs a double-sha digest of the announcement.
|
||||||
|
// This'll serve to authenticate this announcement and any other future
|
||||||
|
// updates we may send.
|
||||||
|
chanUpdateMsg, err := chanUpdateAnn.DataToSign()
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
sig, err := f.cfg.SignMessage(f.cfg.IDKey, chanUpdateMsg)
|
||||||
|
if err != nil {
|
||||||
|
return nil, errors.Errorf("unable to generate channel "+
|
||||||
|
"update announcement signature: %v", err)
|
||||||
|
}
|
||||||
|
chanUpdateAnn.Signature, err = lnwire.NewSigFromSignature(sig)
|
||||||
|
if err != nil {
|
||||||
|
return nil, errors.Errorf("unable to generate channel "+
|
||||||
|
"update announcement signature: %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
// The channel existence proofs itself is currently announced in
|
||||||
|
// distinct message. In order to properly authenticate this message, we
|
||||||
|
// need two signatures: one under the identity public key used which
|
||||||
|
// signs the message itself and another signature of the identity
|
||||||
|
// public key under the funding key itself.
|
||||||
|
//
|
||||||
|
// TODO(roasbeef): use SignAnnouncement here instead?
|
||||||
|
chanAnnMsg, err := chanAnn.DataToSign()
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
nodeSig, err := f.cfg.SignMessage(f.cfg.IDKey, chanAnnMsg)
|
||||||
|
if err != nil {
|
||||||
|
return nil, errors.Errorf("unable to generate node "+
|
||||||
|
"signature for channel announcement: %v", err)
|
||||||
|
}
|
||||||
|
bitcoinSig, err := f.cfg.SignMessage(localFundingKey, chanAnnMsg)
|
||||||
|
if err != nil {
|
||||||
|
return nil, errors.Errorf("unable to generate bitcoin "+
|
||||||
|
"signature for node public key: %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
// Finally, we'll generate the announcement proof which we'll use to
|
||||||
|
// provide the other side with the necessary signatures required to
|
||||||
|
// allow them to reconstruct the full channel announcement.
|
||||||
|
proof := &lnwire.AnnounceSignatures{
|
||||||
|
ChannelID: chanID,
|
||||||
|
ShortChannelID: shortChanID,
|
||||||
|
}
|
||||||
|
proof.NodeSignature, err = lnwire.NewSigFromSignature(nodeSig)
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
proof.BitcoinSignature, err = lnwire.NewSigFromSignature(bitcoinSig)
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
|
||||||
|
return &chanAnnouncement{
|
||||||
|
chanAnn: chanAnn,
|
||||||
|
chanUpdateAnn: chanUpdateAnn,
|
||||||
|
chanProof: proof,
|
||||||
|
}, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// announceChannel announces a newly created channel to the rest of the network
|
||||||
|
// by crafting the two authenticated announcements required for the peers on
|
||||||
|
// the network to recognize the legitimacy of the channel. The crafted
|
||||||
|
// announcements are then sent to the channel router to handle broadcasting to
|
||||||
|
// the network during its next trickle.
|
||||||
|
// This method is synchronous and will return when all the network requests
|
||||||
|
// finish, either successfully or with an error.
|
||||||
|
func (f *Manager) announceChannel(localIDKey, remoteIDKey, localFundingKey,
|
||||||
|
remoteFundingKey *btcec.PublicKey, shortChanID lnwire.ShortChannelID,
|
||||||
|
chanID lnwire.ChannelID) error {
|
||||||
|
|
||||||
|
// First, we'll create the batch of announcements to be sent upon
|
||||||
|
// initial channel creation. This includes the channel announcement
|
||||||
|
// itself, the channel update announcement, and our half of the channel
|
||||||
|
// proof needed to fully authenticate the channel.
|
||||||
|
//
|
||||||
|
// We can pass in zeroes for the min and max htlc policy, because we
|
||||||
|
// only use the channel announcement message from the returned struct.
|
||||||
|
ann, err := f.newChanAnnouncement(localIDKey, remoteIDKey,
|
||||||
|
localFundingKey, remoteFundingKey, shortChanID, chanID,
|
||||||
|
0, 0,
|
||||||
|
)
|
||||||
|
if err != nil {
|
||||||
|
log.Errorf("can't generate channel announcement: %v", err)
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
// We only send the channel proof announcement and the node announcement
|
||||||
|
// because addToRouterGraph previously sent the ChannelAnnouncement and
|
||||||
|
// the ChannelUpdate announcement messages. The channel proof and node
|
||||||
|
// announcements are broadcast to the greater network.
|
||||||
|
errChan := f.cfg.SendAnnouncement(ann.chanProof)
|
||||||
|
select {
|
||||||
|
case err := <-errChan:
|
||||||
|
if err != nil {
|
||||||
|
if routing.IsError(err, routing.ErrOutdated,
|
||||||
|
routing.ErrIgnored) {
|
||||||
|
log.Debugf("Router rejected "+
|
||||||
|
"AnnounceSignatures: %v", err)
|
||||||
|
} else {
|
||||||
|
log.Errorf("Unable to send channel "+
|
||||||
|
"proof: %v", err)
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
case <-f.quit:
|
||||||
|
return ErrFundingManagerShuttingDown
|
||||||
|
}
|
||||||
|
|
||||||
|
// Now that the channel is announced to the network, we will also
|
||||||
|
// obtain and send a node announcement. This is done since a node
|
||||||
|
// announcement is only accepted after a channel is known for that
|
||||||
|
// particular node, and this might be our first channel.
|
||||||
|
nodeAnn, err := f.cfg.CurrentNodeAnnouncement()
|
||||||
|
if err != nil {
|
||||||
|
log.Errorf("can't generate node announcement: %v", err)
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
errChan = f.cfg.SendAnnouncement(&nodeAnn)
|
||||||
|
select {
|
||||||
|
case err := <-errChan:
|
||||||
|
if err != nil {
|
||||||
|
if routing.IsError(err, routing.ErrOutdated,
|
||||||
|
routing.ErrIgnored) {
|
||||||
|
log.Debugf("Router rejected "+
|
||||||
|
"NodeAnnouncement: %v", err)
|
||||||
|
} else {
|
||||||
|
log.Errorf("Unable to send node "+
|
||||||
|
"announcement: %v", err)
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
case <-f.quit:
|
||||||
|
return ErrFundingManagerShuttingDown
|
||||||
|
}
|
||||||
|
|
||||||
|
return nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// InitFundingWorkflow sends a message to the funding manager instructing it
|
||||||
|
// to initiate a single funder workflow with the source peer.
|
||||||
|
// TODO(roasbeef): re-visit blocking nature..
|
||||||
|
func (f *Manager) InitFundingWorkflow(msg *InitFundingMsg) {
|
||||||
|
f.fundingRequests <- msg
|
||||||
|
}
|
||||||
|
|
||||||
|
// getUpfrontShutdownScript takes a user provided script and a getScript
|
||||||
|
// function which can be used to generate an upfront shutdown script. If our
|
||||||
|
// peer does not support the feature, this function will error if a non-zero
|
||||||
|
// script was provided by the user, and return an empty script otherwise. If
|
||||||
|
// our peer does support the feature, we will return the user provided script
|
||||||
|
// if non-zero, or a freshly generated script if our node is configured to set
|
||||||
|
// upfront shutdown scripts automatically.
|
||||||
|
func getUpfrontShutdownScript(enableUpfrontShutdown bool, peer lnpeer.Peer,
|
||||||
|
script lnwire.DeliveryAddress,
|
||||||
|
getScript func() (lnwire.DeliveryAddress, error)) (lnwire.DeliveryAddress,
|
||||||
|
error) {
|
||||||
|
|
||||||
|
// Check whether the remote peer supports upfront shutdown scripts.
|
||||||
|
remoteUpfrontShutdown := peer.RemoteFeatures().HasFeature(
|
||||||
|
lnwire.UpfrontShutdownScriptOptional,
|
||||||
|
)
|
||||||
|
|
||||||
|
// If the peer does not support upfront shutdown scripts, and one has been
|
||||||
|
// provided, return an error because the feature is not supported.
|
||||||
|
if !remoteUpfrontShutdown && len(script) != 0 {
|
||||||
|
return nil, errUpfrontShutdownScriptNotSupported
|
||||||
|
}
|
||||||
|
|
||||||
|
// If the peer does not support upfront shutdown, return an empty address.
|
||||||
|
if !remoteUpfrontShutdown {
|
||||||
|
return nil, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// If the user has provided an script and the peer supports the feature,
|
||||||
|
// return it. Note that user set scripts override the enable upfront
|
||||||
|
// shutdown flag.
|
||||||
|
if len(script) > 0 {
|
||||||
|
return script, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// If we do not have setting of upfront shutdown script enabled, return
|
||||||
|
// an empty script.
|
||||||
|
if !enableUpfrontShutdown {
|
||||||
|
return nil, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
return getScript()
|
||||||
|
}
|
||||||
|
|
||||||
|
// handleInitFundingMsg creates a channel reservation within the daemon's
|
||||||
|
// wallet, then sends a funding request to the remote peer kicking off the
|
||||||
|
// funding workflow.
|
||||||
|
func (f *Manager) handleInitFundingMsg(msg *InitFundingMsg) {
|
||||||
|
var (
|
||||||
|
peerKey = msg.Peer.IdentityKey()
|
||||||
|
localAmt = msg.LocalFundingAmt
|
||||||
|
minHtlcIn = msg.MinHtlcIn
|
||||||
|
remoteCsvDelay = msg.RemoteCsvDelay
|
||||||
|
maxValue = msg.MaxValueInFlight
|
||||||
|
maxHtlcs = msg.MaxHtlcs
|
||||||
|
maxCSV = msg.MaxLocalCsv
|
||||||
|
)
|
||||||
|
|
||||||
|
// If no maximum CSV delay was set for this channel, we use our default
|
||||||
|
// value.
|
||||||
|
if maxCSV == 0 {
|
||||||
|
maxCSV = f.cfg.MaxLocalCSVDelay
|
||||||
|
}
|
||||||
|
|
||||||
|
// We'll determine our dust limit depending on which chain is active.
|
||||||
|
var ourDustLimit btcutil.Amount
|
||||||
|
switch f.cfg.RegisteredChains.PrimaryChain() {
|
||||||
|
case chainreg.BitcoinChain:
|
||||||
|
ourDustLimit = lnwallet.DefaultDustLimit()
|
||||||
|
case chainreg.LitecoinChain:
|
||||||
|
ourDustLimit = chainreg.DefaultLitecoinDustLimit
|
||||||
|
}
|
||||||
|
log.Infof("Initiating fundingRequest(local_amt=%v "+
|
||||||
|
"(subtract_fees=%v), push_amt=%v, chain_hash=%v, peer=%x, "+
|
||||||
|
"dust_limit=%v, min_confs=%v)", localAmt, msg.SubtractFees,
|
||||||
|
msg.PushAmt, msg.ChainHash, peerKey.SerializeCompressed(),
|
||||||
|
ourDustLimit, msg.MinConfs)
|
||||||
|
|
||||||
|
// We set the channel flags to indicate whether we want this channel to
|
||||||
|
// be announced to the network.
|
||||||
|
var channelFlags lnwire.FundingFlag
|
||||||
|
if !msg.Private {
|
||||||
|
// This channel will be announced.
|
||||||
|
channelFlags = lnwire.FFAnnounceChannel
|
||||||
|
}
|
||||||
|
|
||||||
|
// If the caller specified their own channel ID, then we'll use that.
|
||||||
|
// Otherwise we'll generate a fresh one as normal. This will be used
|
||||||
|
// to track this reservation throughout its lifetime.
|
||||||
|
var chanID [32]byte
|
||||||
|
if msg.PendingChanID == zeroID {
|
||||||
|
chanID = f.nextPendingChanID()
|
||||||
|
} else {
|
||||||
|
// If the user specified their own pending channel ID, then
|
||||||
|
// we'll ensure it doesn't collide with any existing pending
|
||||||
|
// channel ID.
|
||||||
|
chanID = msg.PendingChanID
|
||||||
|
if _, err := f.getReservationCtx(peerKey, chanID); err == nil {
|
||||||
|
msg.Err <- fmt.Errorf("pendingChannelID(%x) "+
|
||||||
|
"already present", chanID[:])
|
||||||
|
return
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Check whether the peer supports upfront shutdown, and get an address
|
||||||
|
// which should be used (either a user specified address or a new
|
||||||
|
// address from the wallet if our node is configured to set shutdown
|
||||||
|
// address by default).
|
||||||
|
shutdown, err := getUpfrontShutdownScript(
|
||||||
|
f.cfg.EnableUpfrontShutdown, msg.Peer,
|
||||||
|
msg.ShutdownScript,
|
||||||
|
func() (lnwire.DeliveryAddress, error) {
|
||||||
|
addr, err := f.cfg.Wallet.NewAddress(
|
||||||
|
lnwallet.WitnessPubKey, false,
|
||||||
|
)
|
||||||
|
if err != nil {
|
||||||
|
return nil, err
|
||||||
|
}
|
||||||
|
return txscript.PayToAddrScript(addr)
|
||||||
|
},
|
||||||
|
)
|
||||||
|
if err != nil {
|
||||||
|
msg.Err <- err
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// Initialize a funding reservation with the local wallet. If the
|
||||||
|
// wallet doesn't have enough funds to commit to this channel, then the
|
||||||
|
// request will fail, and be aborted.
|
||||||
|
//
|
||||||
|
// Before we init the channel, we'll also check to see what commitment
|
||||||
|
// format we can use with this peer. This is dependent on *both* us and
|
||||||
|
// the remote peer are signaling the proper feature bit.
|
||||||
|
commitType := commitmentType(
|
||||||
|
msg.Peer.LocalFeatures(), msg.Peer.RemoteFeatures(),
|
||||||
|
)
|
||||||
|
|
||||||
|
// First, we'll query the fee estimator for a fee that should get the
|
||||||
|
// commitment transaction confirmed by the next few blocks (conf target
|
||||||
|
// of 3). We target the near blocks here to ensure that we'll be able
|
||||||
|
// to execute a timely unilateral channel closure if needed.
|
||||||
|
commitFeePerKw, err := f.cfg.FeeEstimator.EstimateFeePerKW(3)
|
||||||
|
if err != nil {
|
||||||
|
msg.Err <- err
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// For anchor channels cap the initial commit fee rate at our defined
|
||||||
|
// maximum.
|
||||||
|
if commitType == lnwallet.CommitmentTypeAnchorsZeroFeeHtlcTx &&
|
||||||
|
commitFeePerKw > f.cfg.MaxAnchorsCommitFeeRate {
|
||||||
|
|
||||||
|
commitFeePerKw = f.cfg.MaxAnchorsCommitFeeRate
|
||||||
|
}
|
||||||
|
|
||||||
|
req := &lnwallet.InitFundingReserveMsg{
|
||||||
|
ChainHash: &msg.ChainHash,
|
||||||
|
PendingChanID: chanID,
|
||||||
|
NodeID: peerKey,
|
||||||
|
NodeAddr: msg.Peer.Address(),
|
||||||
|
SubtractFees: msg.SubtractFees,
|
||||||
|
LocalFundingAmt: localAmt,
|
||||||
|
RemoteFundingAmt: 0,
|
||||||
|
CommitFeePerKw: commitFeePerKw,
|
||||||
|
FundingFeePerKw: msg.FundingFeePerKw,
|
||||||
|
PushMSat: msg.PushAmt,
|
||||||
|
Flags: channelFlags,
|
||||||
|
MinConfs: msg.MinConfs,
|
||||||
|
CommitType: commitType,
|
||||||
|
ChanFunder: msg.ChanFunder,
|
||||||
|
}
|
||||||
|
|
||||||
|
reservation, err := f.cfg.Wallet.InitChannelReservation(req)
|
||||||
|
if err != nil {
|
||||||
|
msg.Err <- err
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// Set our upfront shutdown address in the existing reservation.
|
||||||
|
reservation.SetOurUpfrontShutdown(shutdown)
|
||||||
|
|
||||||
|
// Now that we have successfully reserved funds for this channel in the
|
||||||
|
// wallet, we can fetch the final channel capacity. This is done at
|
||||||
|
// this point since the final capacity might change in case of
|
||||||
|
// SubtractFees=true.
|
||||||
|
capacity := reservation.Capacity()
|
||||||
|
|
||||||
|
log.Infof("Target commit tx sat/kw for pendingID(%x): %v", chanID,
|
||||||
|
int64(commitFeePerKw))
|
||||||
|
|
||||||
|
// If the remote CSV delay was not set in the open channel request,
|
||||||
|
// we'll use the RequiredRemoteDelay closure to compute the delay we
|
||||||
|
// require given the total amount of funds within the channel.
|
||||||
|
if remoteCsvDelay == 0 {
|
||||||
|
remoteCsvDelay = f.cfg.RequiredRemoteDelay(capacity)
|
||||||
|
}
|
||||||
|
|
||||||
|
// If no minimum HTLC value was specified, use the default one.
|
||||||
|
if minHtlcIn == 0 {
|
||||||
|
minHtlcIn = f.cfg.DefaultMinHtlcIn
|
||||||
|
}
|
||||||
|
|
||||||
|
// If no max value was specified, use the default one.
|
||||||
|
if maxValue == 0 {
|
||||||
|
maxValue = f.cfg.RequiredRemoteMaxValue(capacity)
|
||||||
|
}
|
||||||
|
|
||||||
|
if maxHtlcs == 0 {
|
||||||
|
maxHtlcs = f.cfg.RequiredRemoteMaxHTLCs(capacity)
|
||||||
|
}
|
||||||
|
|
||||||
|
// If a pending channel map for this peer isn't already created, then
|
||||||
|
// we create one, ultimately allowing us to track this pending
|
||||||
|
// reservation within the target peer.
|
||||||
|
peerIDKey := newSerializedKey(peerKey)
|
||||||
|
f.resMtx.Lock()
|
||||||
|
if _, ok := f.activeReservations[peerIDKey]; !ok {
|
||||||
|
f.activeReservations[peerIDKey] = make(pendingChannels)
|
||||||
|
}
|
||||||
|
|
||||||
|
resCtx := &reservationWithCtx{
|
||||||
|
chanAmt: capacity,
|
||||||
|
remoteCsvDelay: remoteCsvDelay,
|
||||||
|
remoteMinHtlc: minHtlcIn,
|
||||||
|
remoteMaxValue: maxValue,
|
||||||
|
remoteMaxHtlcs: maxHtlcs,
|
||||||
|
maxLocalCsv: maxCSV,
|
||||||
|
reservation: reservation,
|
||||||
|
peer: msg.Peer,
|
||||||
|
updates: msg.Updates,
|
||||||
|
err: msg.Err,
|
||||||
|
}
|
||||||
|
f.activeReservations[peerIDKey][chanID] = resCtx
|
||||||
|
f.resMtx.Unlock()
|
||||||
|
|
||||||
|
// Update the timestamp once the InitFundingMsg has been handled.
|
||||||
|
defer resCtx.updateTimestamp()
|
||||||
|
|
||||||
|
// Once the reservation has been created, and indexed, queue a funding
|
||||||
|
// request to the remote peer, kicking off the funding workflow.
|
||||||
|
ourContribution := reservation.OurContribution()
|
||||||
|
|
||||||
|
// Finally, we'll use the current value of the channels and our default
|
||||||
|
// policy to determine of required commitment constraints for the
|
||||||
|
// remote party.
|
||||||
|
chanReserve := f.cfg.RequiredRemoteChanReserve(capacity, ourDustLimit)
|
||||||
|
|
||||||
|
log.Infof("Starting funding workflow with %v for pending_id(%x), "+
|
||||||
|
"committype=%v", msg.Peer.Address(), chanID, commitType)
|
||||||
|
|
||||||
|
fundingOpen := lnwire.OpenChannel{
|
||||||
|
ChainHash: *f.cfg.Wallet.Cfg.NetParams.GenesisHash,
|
||||||
|
PendingChannelID: chanID,
|
||||||
|
FundingAmount: capacity,
|
||||||
|
PushAmount: msg.PushAmt,
|
||||||
|
DustLimit: ourContribution.DustLimit,
|
||||||
|
MaxValueInFlight: maxValue,
|
||||||
|
ChannelReserve: chanReserve,
|
||||||
|
HtlcMinimum: minHtlcIn,
|
||||||
|
FeePerKiloWeight: uint32(commitFeePerKw),
|
||||||
|
CsvDelay: remoteCsvDelay,
|
||||||
|
MaxAcceptedHTLCs: maxHtlcs,
|
||||||
|
FundingKey: ourContribution.MultiSigKey.PubKey,
|
||||||
|
RevocationPoint: ourContribution.RevocationBasePoint.PubKey,
|
||||||
|
PaymentPoint: ourContribution.PaymentBasePoint.PubKey,
|
||||||
|
HtlcPoint: ourContribution.HtlcBasePoint.PubKey,
|
||||||
|
DelayedPaymentPoint: ourContribution.DelayBasePoint.PubKey,
|
||||||
|
FirstCommitmentPoint: ourContribution.FirstCommitmentPoint,
|
||||||
|
ChannelFlags: channelFlags,
|
||||||
|
UpfrontShutdownScript: shutdown,
|
||||||
|
}
|
||||||
|
if err := msg.Peer.SendMessage(true, &fundingOpen); err != nil {
|
||||||
|
e := fmt.Errorf("unable to send funding request message: %v",
|
||||||
|
err)
|
||||||
|
log.Errorf(e.Error())
|
||||||
|
|
||||||
|
// Since we were unable to send the initial message to the peer
|
||||||
|
// and start the funding flow, we'll cancel this reservation.
|
||||||
|
_, err := f.cancelReservationCtx(peerKey, chanID, false)
|
||||||
|
if err != nil {
|
||||||
|
log.Errorf("unable to cancel reservation: %v", err)
|
||||||
|
}
|
||||||
|
|
||||||
|
msg.Err <- e
|
||||||
|
return
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// handleErrorMsg processes the error which was received from remote peer,
|
||||||
|
// depending on the type of error we should do different clean up steps and
|
||||||
|
// inform the user about it.
|
||||||
|
func (f *Manager) handleErrorMsg(peer lnpeer.Peer,
|
||||||
|
msg *lnwire.Error) {
|
||||||
|
|
||||||
|
chanID := msg.ChanID
|
||||||
|
peerKey := peer.IdentityKey()
|
||||||
|
|
||||||
|
// First, we'll attempt to retrieve and cancel the funding workflow
|
||||||
|
// that this error was tied to. If we're unable to do so, then we'll
|
||||||
|
// exit early as this was an unwarranted error.
|
||||||
|
resCtx, err := f.cancelReservationCtx(peerKey, chanID, true)
|
||||||
|
if err != nil {
|
||||||
|
log.Warnf("Received error for non-existent funding "+
|
||||||
|
"flow: %v (%v)", err, msg.Error())
|
||||||
|
return
|
||||||
|
}
|
||||||
|
|
||||||
|
// If we did indeed find the funding workflow, then we'll return the
|
||||||
|
// error back to the caller (if any), and cancel the workflow itself.
|
||||||
|
fundingErr := fmt.Errorf("received funding error from %x: %v",
|
||||||
|
peerKey.SerializeCompressed(), msg.Error(),
|
||||||
|
)
|
||||||
|
log.Errorf(fundingErr.Error())
|
||||||
|
|
||||||
|
// If this was a PSBT funding flow, the remote likely timed out because
|
||||||
|
// we waited too long. Return a nice error message to the user in that
|
||||||
|
// case so the user knows what's the problem.
|
||||||
|
if resCtx.reservation.IsPsbt() {
|
||||||
|
fundingErr = fmt.Errorf("%w: %v", chanfunding.ErrRemoteCanceled,
|
||||||
|
fundingErr)
|
||||||
|
}
|
||||||
|
|
||||||
|
resCtx.err <- fundingErr
|
||||||
|
}
|
||||||
|
|
||||||
|
// pruneZombieReservations loops through all pending reservations and fails the
|
||||||
|
// funding flow for any reservations that have not been updated since the
|
||||||
|
// ReservationTimeout and are not locked waiting for the funding transaction.
|
||||||
|
func (f *Manager) pruneZombieReservations() {
|
||||||
|
zombieReservations := make(pendingChannels)
|
||||||
|
|
||||||
|
f.resMtx.RLock()
|
||||||
|
for _, pendingReservations := range f.activeReservations {
|
||||||
|
for pendingChanID, resCtx := range pendingReservations {
|
||||||
|
if resCtx.isLocked() {
|
||||||
|
continue
|
||||||
|
}
|
||||||
|
|
||||||
|
// We don't want to expire PSBT funding reservations.
|
||||||
|
// These reservations are always initiated by us and the
|
||||||
|
// remote peer is likely going to cancel them after some
|
||||||
|
// idle time anyway. So no need for us to also prune
|
||||||
|
// them.
|
||||||
|
sinceLastUpdate := time.Since(resCtx.lastUpdated)
|
||||||
|
isExpired := sinceLastUpdate > f.cfg.ReservationTimeout
|
||||||
|
if !resCtx.reservation.IsPsbt() && isExpired {
|
||||||
|
zombieReservations[pendingChanID] = resCtx
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
f.resMtx.RUnlock()
|
||||||
|
|
||||||
|
for pendingChanID, resCtx := range zombieReservations {
|
||||||
|
err := fmt.Errorf("reservation timed out waiting for peer "+
|
||||||
|
"(peer_id:%x, chan_id:%x)", resCtx.peer.IdentityKey(),
|
||||||
|
pendingChanID[:])
|
||||||
|
log.Warnf(err.Error())
|
||||||
|
f.failFundingFlow(resCtx.peer, pendingChanID, err)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// cancelReservationCtx does all needed work in order to securely cancel the
|
||||||
|
// reservation.
|
||||||
|
func (f *Manager) cancelReservationCtx(peerKey *btcec.PublicKey,
|
||||||
|
pendingChanID [32]byte, byRemote bool) (*reservationWithCtx, error) {
|
||||||
|
|
||||||
|
log.Infof("Cancelling funding reservation for node_key=%x, "+
|
||||||
|
"chan_id=%x", peerKey.SerializeCompressed(), pendingChanID[:])
|
||||||
|
|
||||||
|
peerIDKey := newSerializedKey(peerKey)
|
||||||
|
f.resMtx.Lock()
|
||||||
|
defer f.resMtx.Unlock()
|
||||||
|
|
||||||
|
nodeReservations, ok := f.activeReservations[peerIDKey]
|
||||||
|
if !ok {
|
||||||
|
// No reservations for this node.
|
||||||
|
return nil, errors.Errorf("no active reservations for peer(%x)",
|
||||||
|
peerIDKey[:])
|
||||||
|
}
|
||||||
|
|
||||||
|
ctx, ok := nodeReservations[pendingChanID]
|
||||||
|
if !ok {
|
||||||
|
return nil, errors.Errorf("unknown channel (id: %x) for "+
|
||||||
|
"peer(%x)", pendingChanID[:], peerIDKey[:])
|
||||||
|
}
|
||||||
|
|
||||||
|
// If the reservation was a PSBT funding flow and it was canceled by the
|
||||||
|
// remote peer, then we need to thread through a different error message
|
||||||
|
// to the subroutine that's waiting for the user input so it can return
|
||||||
|
// a nice error message to the user.
|
||||||
|
if ctx.reservation.IsPsbt() && byRemote {
|
||||||
|
ctx.reservation.RemoteCanceled()
|
||||||
|
}
|
||||||
|
|
||||||
|
if err := ctx.reservation.Cancel(); err != nil {
|
||||||
|
return nil, errors.Errorf("unable to cancel reservation: %v",
|
||||||
|
err)
|
||||||
|
}
|
||||||
|
|
||||||
|
delete(nodeReservations, pendingChanID)
|
||||||
|
|
||||||
|
// If this was the last active reservation for this peer, delete the
|
||||||
|
// peer's entry altogether.
|
||||||
|
if len(nodeReservations) == 0 {
|
||||||
|
delete(f.activeReservations, peerIDKey)
|
||||||
|
}
|
||||||
|
return ctx, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// deleteReservationCtx deletes the reservation uniquely identified by the
|
||||||
|
// target public key of the peer, and the specified pending channel ID.
|
||||||
|
func (f *Manager) deleteReservationCtx(peerKey *btcec.PublicKey,
|
||||||
|
pendingChanID [32]byte) {
|
||||||
|
|
||||||
|
// TODO(roasbeef): possibly cancel funding barrier in peer's
|
||||||
|
// channelManager?
|
||||||
|
peerIDKey := newSerializedKey(peerKey)
|
||||||
|
f.resMtx.Lock()
|
||||||
|
defer f.resMtx.Unlock()
|
||||||
|
|
||||||
|
nodeReservations, ok := f.activeReservations[peerIDKey]
|
||||||
|
if !ok {
|
||||||
|
// No reservations for this node.
|
||||||
|
return
|
||||||
|
}
|
||||||
|
delete(nodeReservations, pendingChanID)
|
||||||
|
|
||||||
|
// If this was the last active reservation for this peer, delete the
|
||||||
|
// peer's entry altogether.
|
||||||
|
if len(nodeReservations) == 0 {
|
||||||
|
delete(f.activeReservations, peerIDKey)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// getReservationCtx returns the reservation context for a particular pending
|
||||||
|
// channel ID for a target peer.
|
||||||
|
func (f *Manager) getReservationCtx(peerKey *btcec.PublicKey,
|
||||||
|
pendingChanID [32]byte) (*reservationWithCtx, error) {
|
||||||
|
|
||||||
|
peerIDKey := newSerializedKey(peerKey)
|
||||||
|
f.resMtx.RLock()
|
||||||
|
resCtx, ok := f.activeReservations[peerIDKey][pendingChanID]
|
||||||
|
f.resMtx.RUnlock()
|
||||||
|
|
||||||
|
if !ok {
|
||||||
|
return nil, errors.Errorf("unknown channel (id: %x) for "+
|
||||||
|
"peer(%x)", pendingChanID[:], peerIDKey[:])
|
||||||
|
}
|
||||||
|
|
||||||
|
return resCtx, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// IsPendingChannel returns a boolean indicating whether the channel identified
|
||||||
|
// by the pendingChanID and given peer is pending, meaning it is in the process
|
||||||
|
// of being funded. After the funding transaction has been confirmed, the
|
||||||
|
// channel will receive a new, permanent channel ID, and will no longer be
|
||||||
|
// considered pending.
|
||||||
|
func (f *Manager) IsPendingChannel(pendingChanID [32]byte,
|
||||||
|
peer lnpeer.Peer) bool {
|
||||||
|
|
||||||
|
peerIDKey := newSerializedKey(peer.IdentityKey())
|
||||||
|
f.resMtx.RLock()
|
||||||
|
_, ok := f.activeReservations[peerIDKey][pendingChanID]
|
||||||
|
f.resMtx.RUnlock()
|
||||||
|
|
||||||
|
return ok
|
||||||
|
}
|
||||||
|
|
||||||
|
func copyPubKey(pub *btcec.PublicKey) *btcec.PublicKey {
|
||||||
|
return &btcec.PublicKey{
|
||||||
|
Curve: btcec.S256(),
|
||||||
|
X: pub.X,
|
||||||
|
Y: pub.Y,
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// saveChannelOpeningState saves the channelOpeningState for the provided
|
||||||
|
// chanPoint to the channelOpeningStateBucket.
|
||||||
|
func (f *Manager) saveChannelOpeningState(chanPoint *wire.OutPoint,
|
||||||
|
state channelOpeningState, shortChanID *lnwire.ShortChannelID) error {
|
||||||
|
return kvdb.Update(f.cfg.Wallet.Cfg.Database, func(tx kvdb.RwTx) error {
|
||||||
|
|
||||||
|
bucket, err := tx.CreateTopLevelBucket(channelOpeningStateBucket)
|
||||||
|
if err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
var outpointBytes bytes.Buffer
|
||||||
|
if err = WriteOutpoint(&outpointBytes, chanPoint); err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
// Save state and the uint64 representation of the shortChanID
|
||||||
|
// for later use.
|
||||||
|
scratch := make([]byte, 10)
|
||||||
|
byteOrder.PutUint16(scratch[:2], uint16(state))
|
||||||
|
byteOrder.PutUint64(scratch[2:], shortChanID.ToUint64())
|
||||||
|
|
||||||
|
return bucket.Put(outpointBytes.Bytes(), scratch)
|
||||||
|
}, func() {})
|
||||||
|
}
|
||||||
|
|
||||||
|
// getChannelOpeningState fetches the channelOpeningState for the provided
|
||||||
|
// chanPoint from the database, or returns ErrChannelNotFound if the channel
|
||||||
|
// is not found.
|
||||||
|
func (f *Manager) getChannelOpeningState(chanPoint *wire.OutPoint) (
|
||||||
|
channelOpeningState, *lnwire.ShortChannelID, error) {
|
||||||
|
|
||||||
|
var state channelOpeningState
|
||||||
|
var shortChanID lnwire.ShortChannelID
|
||||||
|
err := kvdb.View(f.cfg.Wallet.Cfg.Database, func(tx kvdb.RTx) error {
|
||||||
|
|
||||||
|
bucket := tx.ReadBucket(channelOpeningStateBucket)
|
||||||
|
if bucket == nil {
|
||||||
|
// If the bucket does not exist, it means we never added
|
||||||
|
// a channel to the db, so return ErrChannelNotFound.
|
||||||
|
return ErrChannelNotFound
|
||||||
|
}
|
||||||
|
|
||||||
|
var outpointBytes bytes.Buffer
|
||||||
|
if err := WriteOutpoint(&outpointBytes, chanPoint); err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
value := bucket.Get(outpointBytes.Bytes())
|
||||||
|
if value == nil {
|
||||||
|
return ErrChannelNotFound
|
||||||
|
}
|
||||||
|
|
||||||
|
state = channelOpeningState(byteOrder.Uint16(value[:2]))
|
||||||
|
shortChanID = lnwire.NewShortChanIDFromInt(byteOrder.Uint64(value[2:]))
|
||||||
|
return nil
|
||||||
|
}, func() {})
|
||||||
|
if err != nil {
|
||||||
|
return 0, nil, err
|
||||||
|
}
|
||||||
|
|
||||||
|
return state, &shortChanID, nil
|
||||||
|
}
|
||||||
|
|
||||||
|
// deleteChannelOpeningState removes any state for chanPoint from the database.
|
||||||
|
func (f *Manager) deleteChannelOpeningState(chanPoint *wire.OutPoint) error {
|
||||||
|
return kvdb.Update(f.cfg.Wallet.Cfg.Database, func(tx kvdb.RwTx) error {
|
||||||
|
bucket := tx.ReadWriteBucket(channelOpeningStateBucket)
|
||||||
|
if bucket == nil {
|
||||||
|
return fmt.Errorf("bucket not found")
|
||||||
|
}
|
||||||
|
|
||||||
|
var outpointBytes bytes.Buffer
|
||||||
|
if err := WriteOutpoint(&outpointBytes, chanPoint); err != nil {
|
||||||
|
return err
|
||||||
|
}
|
||||||
|
|
||||||
|
return bucket.Delete(outpointBytes.Bytes())
|
||||||
|
}, func() {})
|
||||||
|
}
|
||||||
|
@ -1,6 +1,6 @@
|
|||||||
// +build !rpctest
|
// +build !rpctest
|
||||||
|
|
||||||
package lnd
|
package funding
|
||||||
|
|
||||||
import (
|
import (
|
||||||
"bytes"
|
"bytes"
|
||||||
@ -27,7 +27,6 @@ import (
|
|||||||
"github.com/lightningnetwork/lnd/channeldb"
|
"github.com/lightningnetwork/lnd/channeldb"
|
||||||
"github.com/lightningnetwork/lnd/channelnotifier"
|
"github.com/lightningnetwork/lnd/channelnotifier"
|
||||||
"github.com/lightningnetwork/lnd/discovery"
|
"github.com/lightningnetwork/lnd/discovery"
|
||||||
"github.com/lightningnetwork/lnd/funding"
|
|
||||||
"github.com/lightningnetwork/lnd/htlcswitch"
|
"github.com/lightningnetwork/lnd/htlcswitch"
|
||||||
"github.com/lightningnetwork/lnd/input"
|
"github.com/lightningnetwork/lnd/input"
|
||||||
"github.com/lightningnetwork/lnd/keychain"
|
"github.com/lightningnetwork/lnd/keychain"
|
||||||
@ -60,6 +59,10 @@ const (
|
|||||||
|
|
||||||
// A dummy value to use for the funding broadcast height.
|
// A dummy value to use for the funding broadcast height.
|
||||||
fundingBroadcastHeight = 123
|
fundingBroadcastHeight = 123
|
||||||
|
|
||||||
|
// defaultMaxLocalCSVDelay is the maximum delay we accept on our
|
||||||
|
// commitment output.
|
||||||
|
defaultMaxLocalCSVDelay = 10000
|
||||||
)
|
)
|
||||||
|
|
||||||
var (
|
var (
|
||||||
@ -347,7 +350,7 @@ func createTestFundingManager(t *testing.T, privKey *btcec.PrivateKey,
|
|||||||
|
|
||||||
chainedAcceptor := chanacceptor.NewChainedAcceptor()
|
chainedAcceptor := chanacceptor.NewChainedAcceptor()
|
||||||
|
|
||||||
fundingCfg := fundingConfig{
|
fundingCfg := Config{
|
||||||
IDKey: privKey.PubKey(),
|
IDKey: privKey.PubKey(),
|
||||||
Wallet: lnw,
|
Wallet: lnw,
|
||||||
Notifier: chainNotifier,
|
Notifier: chainNotifier,
|
||||||
@ -434,7 +437,7 @@ func createTestFundingManager(t *testing.T, privKey *btcec.PrivateKey,
|
|||||||
},
|
},
|
||||||
ZombieSweeperInterval: 1 * time.Hour,
|
ZombieSweeperInterval: 1 * time.Hour,
|
||||||
ReservationTimeout: 1 * time.Nanosecond,
|
ReservationTimeout: 1 * time.Nanosecond,
|
||||||
MaxChanSize: funding.MaxBtcFundingAmount,
|
MaxChanSize: MaxBtcFundingAmount,
|
||||||
MaxLocalCSVDelay: defaultMaxLocalCSVDelay,
|
MaxLocalCSVDelay: defaultMaxLocalCSVDelay,
|
||||||
MaxPendingChannels: lncfg.DefaultMaxPendingChannels,
|
MaxPendingChannels: lncfg.DefaultMaxPendingChannels,
|
||||||
NotifyOpenChannelEvent: evt.NotifyOpenChannelEvent,
|
NotifyOpenChannelEvent: evt.NotifyOpenChannelEvent,
|
||||||
@ -492,7 +495,7 @@ func recreateAliceFundingManager(t *testing.T, alice *testNode) {
|
|||||||
|
|
||||||
chainedAcceptor := chanacceptor.NewChainedAcceptor()
|
chainedAcceptor := chanacceptor.NewChainedAcceptor()
|
||||||
|
|
||||||
f, err := NewFundingManager(fundingConfig{
|
f, err := NewFundingManager(Config{
|
||||||
IDKey: oldCfg.IDKey,
|
IDKey: oldCfg.IDKey,
|
||||||
Wallet: oldCfg.Wallet,
|
Wallet: oldCfg.Wallet,
|
||||||
Notifier: oldCfg.Notifier,
|
Notifier: oldCfg.Notifier,
|
||||||
@ -557,7 +560,7 @@ func recreateAliceFundingManager(t *testing.T, alice *testNode) {
|
|||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
type cfgOption func(*fundingConfig)
|
type cfgOption func(*Config)
|
||||||
|
|
||||||
func setupFundingManagers(t *testing.T,
|
func setupFundingManagers(t *testing.T,
|
||||||
options ...cfgOption) (*testNode, *testNode) {
|
options ...cfgOption) (*testNode, *testNode) {
|
||||||
@ -2864,7 +2867,7 @@ func TestFundingManagerMaxPendingChannels(t *testing.T) {
|
|||||||
t.Parallel()
|
t.Parallel()
|
||||||
|
|
||||||
alice, bob := setupFundingManagers(
|
alice, bob := setupFundingManagers(
|
||||||
t, func(cfg *fundingConfig) {
|
t, func(cfg *Config) {
|
||||||
cfg.MaxPendingChannels = maxPending
|
cfg.MaxPendingChannels = maxPending
|
||||||
},
|
},
|
||||||
)
|
)
|
||||||
@ -3037,7 +3040,7 @@ func TestFundingManagerRejectPush(t *testing.T) {
|
|||||||
|
|
||||||
// Enable 'rejectpush' option and initialize funding managers.
|
// Enable 'rejectpush' option and initialize funding managers.
|
||||||
alice, bob := setupFundingManagers(
|
alice, bob := setupFundingManagers(
|
||||||
t, func(cfg *fundingConfig) {
|
t, func(cfg *Config) {
|
||||||
cfg.RejectPush = true
|
cfg.RejectPush = true
|
||||||
},
|
},
|
||||||
)
|
)
|
||||||
@ -3377,10 +3380,10 @@ func TestMaxChannelSizeConfig(t *testing.T) {
|
|||||||
// Create a set of funding managers that will reject wumbo
|
// Create a set of funding managers that will reject wumbo
|
||||||
// channels but set --maxchansize explicitly lower than soft-limit.
|
// channels but set --maxchansize explicitly lower than soft-limit.
|
||||||
// Verify that wumbo rejecting funding managers will respect --maxchansize
|
// Verify that wumbo rejecting funding managers will respect --maxchansize
|
||||||
// below 16777215 satoshi (funding.MaxBtcFundingAmount) limit.
|
// below 16777215 satoshi (MaxBtcFundingAmount) limit.
|
||||||
alice, bob := setupFundingManagers(t, func(cfg *fundingConfig) {
|
alice, bob := setupFundingManagers(t, func(cfg *Config) {
|
||||||
cfg.NoWumboChans = true
|
cfg.NoWumboChans = true
|
||||||
cfg.MaxChanSize = funding.MaxBtcFundingAmount - 1
|
cfg.MaxChanSize = MaxBtcFundingAmount - 1
|
||||||
})
|
})
|
||||||
|
|
||||||
// Attempt to create a channel above the limit
|
// Attempt to create a channel above the limit
|
||||||
@ -3391,7 +3394,7 @@ func TestMaxChannelSizeConfig(t *testing.T) {
|
|||||||
Peer: bob,
|
Peer: bob,
|
||||||
TargetPubkey: bob.privKey.PubKey(),
|
TargetPubkey: bob.privKey.PubKey(),
|
||||||
ChainHash: *fundingNetParams.GenesisHash,
|
ChainHash: *fundingNetParams.GenesisHash,
|
||||||
LocalFundingAmt: funding.MaxBtcFundingAmount,
|
LocalFundingAmt: MaxBtcFundingAmount,
|
||||||
PushAmt: lnwire.NewMSatFromSatoshis(0),
|
PushAmt: lnwire.NewMSatFromSatoshis(0),
|
||||||
Private: false,
|
Private: false,
|
||||||
Updates: updateChan,
|
Updates: updateChan,
|
||||||
@ -3409,9 +3412,9 @@ func TestMaxChannelSizeConfig(t *testing.T) {
|
|||||||
// channels but set --maxchansize explicitly higher than soft-limit
|
// channels but set --maxchansize explicitly higher than soft-limit
|
||||||
// A --maxchansize greater than this limit should have no effect.
|
// A --maxchansize greater than this limit should have no effect.
|
||||||
tearDownFundingManagers(t, alice, bob)
|
tearDownFundingManagers(t, alice, bob)
|
||||||
alice, bob = setupFundingManagers(t, func(cfg *fundingConfig) {
|
alice, bob = setupFundingManagers(t, func(cfg *Config) {
|
||||||
cfg.NoWumboChans = true
|
cfg.NoWumboChans = true
|
||||||
cfg.MaxChanSize = funding.MaxBtcFundingAmount + 1
|
cfg.MaxChanSize = MaxBtcFundingAmount + 1
|
||||||
})
|
})
|
||||||
|
|
||||||
// Reset the Peer to the newly created one.
|
// Reset the Peer to the newly created one.
|
||||||
@ -3427,7 +3430,7 @@ func TestMaxChannelSizeConfig(t *testing.T) {
|
|||||||
// Create the funding managers, this time allowing
|
// Create the funding managers, this time allowing
|
||||||
// wumbo channels but setting --maxchansize explicitly.
|
// wumbo channels but setting --maxchansize explicitly.
|
||||||
tearDownFundingManagers(t, alice, bob)
|
tearDownFundingManagers(t, alice, bob)
|
||||||
alice, bob = setupFundingManagers(t, func(cfg *fundingConfig) {
|
alice, bob = setupFundingManagers(t, func(cfg *Config) {
|
||||||
cfg.NoWumboChans = false
|
cfg.NoWumboChans = false
|
||||||
cfg.MaxChanSize = btcutil.Amount(100000000)
|
cfg.MaxChanSize = btcutil.Amount(100000000)
|
||||||
})
|
})
|
||||||
@ -3454,7 +3457,7 @@ func TestWumboChannelConfig(t *testing.T) {
|
|||||||
|
|
||||||
// First we'll create a set of funding managers that will reject wumbo
|
// First we'll create a set of funding managers that will reject wumbo
|
||||||
// channels.
|
// channels.
|
||||||
alice, bob := setupFundingManagers(t, func(cfg *fundingConfig) {
|
alice, bob := setupFundingManagers(t, func(cfg *Config) {
|
||||||
cfg.NoWumboChans = true
|
cfg.NoWumboChans = true
|
||||||
})
|
})
|
||||||
|
|
||||||
@ -3467,7 +3470,7 @@ func TestWumboChannelConfig(t *testing.T) {
|
|||||||
Peer: bob,
|
Peer: bob,
|
||||||
TargetPubkey: bob.privKey.PubKey(),
|
TargetPubkey: bob.privKey.PubKey(),
|
||||||
ChainHash: *fundingNetParams.GenesisHash,
|
ChainHash: *fundingNetParams.GenesisHash,
|
||||||
LocalFundingAmt: funding.MaxBtcFundingAmount,
|
LocalFundingAmt: MaxBtcFundingAmount,
|
||||||
PushAmt: lnwire.NewMSatFromSatoshis(0),
|
PushAmt: lnwire.NewMSatFromSatoshis(0),
|
||||||
Private: false,
|
Private: false,
|
||||||
Updates: updateChan,
|
Updates: updateChan,
|
||||||
@ -3494,9 +3497,9 @@ func TestWumboChannelConfig(t *testing.T) {
|
|||||||
// Next, we'll re-create the funding managers, but this time allowing
|
// Next, we'll re-create the funding managers, but this time allowing
|
||||||
// wumbo channels explicitly.
|
// wumbo channels explicitly.
|
||||||
tearDownFundingManagers(t, alice, bob)
|
tearDownFundingManagers(t, alice, bob)
|
||||||
alice, bob = setupFundingManagers(t, func(cfg *fundingConfig) {
|
alice, bob = setupFundingManagers(t, func(cfg *Config) {
|
||||||
cfg.NoWumboChans = false
|
cfg.NoWumboChans = false
|
||||||
cfg.MaxChanSize = funding.MaxBtcFundingAmountWumbo
|
cfg.MaxChanSize = MaxBtcFundingAmountWumbo
|
||||||
})
|
})
|
||||||
|
|
||||||
// Reset the Peer to the newly created one.
|
// Reset the Peer to the newly created one.
|
3540
fundingmanager.go
3540
fundingmanager.go
@ -1,3540 +0,0 @@
|
|||||||
package lnd
|
|
||||||
|
|
||||||
import (
|
|
||||||
"bytes"
|
|
||||||
"encoding/binary"
|
|
||||||
"fmt"
|
|
||||||
"sync"
|
|
||||||
"time"
|
|
||||||
|
|
||||||
"github.com/btcsuite/btcd/btcec"
|
|
||||||
"github.com/btcsuite/btcd/chaincfg/chainhash"
|
|
||||||
"github.com/btcsuite/btcd/txscript"
|
|
||||||
"github.com/btcsuite/btcd/wire"
|
|
||||||
"github.com/btcsuite/btcutil"
|
|
||||||
"github.com/davecgh/go-spew/spew"
|
|
||||||
"github.com/go-errors/errors"
|
|
||||||
"github.com/lightningnetwork/lnd/chainntnfs"
|
|
||||||
"github.com/lightningnetwork/lnd/chainreg"
|
|
||||||
"github.com/lightningnetwork/lnd/chanacceptor"
|
|
||||||
"github.com/lightningnetwork/lnd/channeldb"
|
|
||||||
"github.com/lightningnetwork/lnd/channeldb/kvdb"
|
|
||||||
"github.com/lightningnetwork/lnd/discovery"
|
|
||||||
"github.com/lightningnetwork/lnd/funding"
|
|
||||||
"github.com/lightningnetwork/lnd/htlcswitch"
|
|
||||||
"github.com/lightningnetwork/lnd/input"
|
|
||||||
"github.com/lightningnetwork/lnd/keychain"
|
|
||||||
"github.com/lightningnetwork/lnd/labels"
|
|
||||||
"github.com/lightningnetwork/lnd/lnpeer"
|
|
||||||
"github.com/lightningnetwork/lnd/lnrpc"
|
|
||||||
"github.com/lightningnetwork/lnd/lnwallet"
|
|
||||||
"github.com/lightningnetwork/lnd/lnwallet/chainfee"
|
|
||||||
"github.com/lightningnetwork/lnd/lnwallet/chanfunding"
|
|
||||||
"github.com/lightningnetwork/lnd/lnwire"
|
|
||||||
"github.com/lightningnetwork/lnd/routing"
|
|
||||||
"golang.org/x/crypto/salsa20"
|
|
||||||
)
|
|
||||||
|
|
||||||
const (
|
|
||||||
// TODO(roasbeef): tune
|
|
||||||
msgBufferSize = 50
|
|
||||||
|
|
||||||
// maxWaitNumBlocksFundingConf is the maximum number of blocks to wait
|
|
||||||
// for the funding transaction to be confirmed before forgetting
|
|
||||||
// channels that aren't initiated by us. 2016 blocks is ~2 weeks.
|
|
||||||
maxWaitNumBlocksFundingConf = 2016
|
|
||||||
)
|
|
||||||
|
|
||||||
var (
|
|
||||||
// ErrFundingManagerShuttingDown is an error returned when attempting to
|
|
||||||
// process a funding request/message but the funding manager has already
|
|
||||||
// been signaled to shut down.
|
|
||||||
ErrFundingManagerShuttingDown = errors.New("funding manager shutting " +
|
|
||||||
"down")
|
|
||||||
|
|
||||||
// ErrConfirmationTimeout is an error returned when we as a responder
|
|
||||||
// are waiting for a funding transaction to confirm, but too many
|
|
||||||
// blocks pass without confirmation.
|
|
||||||
ErrConfirmationTimeout = errors.New("timeout waiting for funding " +
|
|
||||||
"confirmation")
|
|
||||||
|
|
||||||
// errUpfrontShutdownScriptNotSupported is returned if an upfront shutdown
|
|
||||||
// script is set for a peer that does not support the feature bit.
|
|
||||||
errUpfrontShutdownScriptNotSupported = errors.New("peer does not support" +
|
|
||||||
"option upfront shutdown script")
|
|
||||||
|
|
||||||
zeroID [32]byte
|
|
||||||
)
|
|
||||||
|
|
||||||
// reservationWithCtx encapsulates a pending channel reservation. This wrapper
|
|
||||||
// struct is used internally within the funding manager to track and progress
|
|
||||||
// the funding workflow initiated by incoming/outgoing methods from the target
|
|
||||||
// peer. Additionally, this struct houses a response and error channel which is
|
|
||||||
// used to respond to the caller in the case a channel workflow is initiated
|
|
||||||
// via a local signal such as RPC.
|
|
||||||
//
|
|
||||||
// TODO(roasbeef): actually use the context package
|
|
||||||
// * deadlines, etc.
|
|
||||||
type reservationWithCtx struct {
|
|
||||||
reservation *lnwallet.ChannelReservation
|
|
||||||
peer lnpeer.Peer
|
|
||||||
|
|
||||||
chanAmt btcutil.Amount
|
|
||||||
|
|
||||||
// Constraints we require for the remote.
|
|
||||||
remoteCsvDelay uint16
|
|
||||||
remoteMinHtlc lnwire.MilliSatoshi
|
|
||||||
remoteMaxValue lnwire.MilliSatoshi
|
|
||||||
remoteMaxHtlcs uint16
|
|
||||||
|
|
||||||
// maxLocalCsv is the maximum csv we will accept from the remote.
|
|
||||||
maxLocalCsv uint16
|
|
||||||
|
|
||||||
updateMtx sync.RWMutex
|
|
||||||
lastUpdated time.Time
|
|
||||||
|
|
||||||
updates chan *lnrpc.OpenStatusUpdate
|
|
||||||
err chan error
|
|
||||||
}
|
|
||||||
|
|
||||||
// isLocked checks the reservation's timestamp to determine whether it is locked.
|
|
||||||
func (r *reservationWithCtx) isLocked() bool {
|
|
||||||
r.updateMtx.RLock()
|
|
||||||
defer r.updateMtx.RUnlock()
|
|
||||||
|
|
||||||
// The time zero value represents a locked reservation.
|
|
||||||
return r.lastUpdated.IsZero()
|
|
||||||
}
|
|
||||||
|
|
||||||
// updateTimestamp updates the reservation's timestamp with the current time.
|
|
||||||
func (r *reservationWithCtx) updateTimestamp() {
|
|
||||||
r.updateMtx.Lock()
|
|
||||||
defer r.updateMtx.Unlock()
|
|
||||||
|
|
||||||
r.lastUpdated = time.Now()
|
|
||||||
}
|
|
||||||
|
|
||||||
// InitFundingMsg is sent by an outside subsystem to the funding manager in
|
|
||||||
// order to kick off a funding workflow with a specified target peer. The
|
|
||||||
// original request which defines the parameters of the funding workflow are
|
|
||||||
// embedded within this message giving the funding manager full context w.r.t
|
|
||||||
// the workflow.
|
|
||||||
type InitFundingMsg struct {
|
|
||||||
// Peer is the peer that we want to open a channel to.
|
|
||||||
Peer lnpeer.Peer
|
|
||||||
|
|
||||||
// TargetPubkey is the public key of the peer.
|
|
||||||
TargetPubkey *btcec.PublicKey
|
|
||||||
|
|
||||||
// ChainHash is the target genesis hash for this channel.
|
|
||||||
ChainHash chainhash.Hash
|
|
||||||
|
|
||||||
// SubtractFees set to true means that fees will be subtracted
|
|
||||||
// from the LocalFundingAmt.
|
|
||||||
SubtractFees bool
|
|
||||||
|
|
||||||
// LocalFundingAmt is the size of the channel.
|
|
||||||
LocalFundingAmt btcutil.Amount
|
|
||||||
|
|
||||||
// PushAmt is the amount pushed to the counterparty.
|
|
||||||
PushAmt lnwire.MilliSatoshi
|
|
||||||
|
|
||||||
// FundingFeePerKw is the fee for the funding transaction.
|
|
||||||
FundingFeePerKw chainfee.SatPerKWeight
|
|
||||||
|
|
||||||
// Private determines whether or not this channel will be private.
|
|
||||||
Private bool
|
|
||||||
|
|
||||||
// MinHtlcIn is the minimum incoming HTLC that we accept.
|
|
||||||
MinHtlcIn lnwire.MilliSatoshi
|
|
||||||
|
|
||||||
// RemoteCsvDelay is the CSV delay we require for the remote peer.
|
|
||||||
RemoteCsvDelay uint16
|
|
||||||
|
|
||||||
// MinConfs indicates the minimum number of confirmations that each
|
|
||||||
// output selected to fund the channel should satisfy.
|
|
||||||
MinConfs int32
|
|
||||||
|
|
||||||
// ShutdownScript is an optional upfront shutdown script for the
|
|
||||||
// channel. This value is optional, so may be nil.
|
|
||||||
ShutdownScript lnwire.DeliveryAddress
|
|
||||||
|
|
||||||
// MaxValueInFlight is the maximum amount of coins in MilliSatoshi
|
|
||||||
// that can be pending within the channel. It only applies to the
|
|
||||||
// remote party.
|
|
||||||
MaxValueInFlight lnwire.MilliSatoshi
|
|
||||||
|
|
||||||
// MaxHtlcs is the maximum number of HTLCs that the remote peer
|
|
||||||
// can offer us.
|
|
||||||
MaxHtlcs uint16
|
|
||||||
|
|
||||||
// MaxLocalCsv is the maximum local csv delay we will accept from our
|
|
||||||
// peer.
|
|
||||||
MaxLocalCsv uint16
|
|
||||||
|
|
||||||
// ChanFunder is an optional channel funder that allows the caller to
|
|
||||||
// control exactly how the channel funding is carried out. If not
|
|
||||||
// specified, then the default chanfunding.WalletAssembler will be
|
|
||||||
// used.
|
|
||||||
ChanFunder chanfunding.Assembler
|
|
||||||
|
|
||||||
// PendingChanID is not all zeroes (the default value), then this will
|
|
||||||
// be the pending channel ID used for the funding flow within the wire
|
|
||||||
// protocol.
|
|
||||||
PendingChanID [32]byte
|
|
||||||
|
|
||||||
// Updates is a channel which updates to the opening status of the channel
|
|
||||||
// are sent on.
|
|
||||||
Updates chan *lnrpc.OpenStatusUpdate
|
|
||||||
|
|
||||||
// Err is a channel which errors encountered during the funding flow are
|
|
||||||
// sent on.
|
|
||||||
Err chan error
|
|
||||||
}
|
|
||||||
|
|
||||||
// fundingMsg is sent by the ProcessFundingMsg function and packages a
|
|
||||||
// funding-specific lnwire.Message along with the lnpeer.Peer that sent it.
|
|
||||||
type fundingMsg struct {
|
|
||||||
msg lnwire.Message
|
|
||||||
peer lnpeer.Peer
|
|
||||||
}
|
|
||||||
|
|
||||||
// pendingChannels is a map instantiated per-peer which tracks all active
|
|
||||||
// pending single funded channels indexed by their pending channel identifier,
|
|
||||||
// which is a set of 32-bytes generated via a CSPRNG.
|
|
||||||
type pendingChannels map[[32]byte]*reservationWithCtx
|
|
||||||
|
|
||||||
// serializedPubKey is used within the FundingManager's activeReservations list
|
|
||||||
// to identify the nodes with which the FundingManager is actively working to
|
|
||||||
// initiate new channels.
|
|
||||||
type serializedPubKey [33]byte
|
|
||||||
|
|
||||||
// newSerializedKey creates a new serialized public key from an instance of a
|
|
||||||
// live pubkey object.
|
|
||||||
func newSerializedKey(pubKey *btcec.PublicKey) serializedPubKey {
|
|
||||||
var s serializedPubKey
|
|
||||||
copy(s[:], pubKey.SerializeCompressed())
|
|
||||||
return s
|
|
||||||
}
|
|
||||||
|
|
||||||
// fundingConfig defines the configuration for the FundingManager. All elements
|
|
||||||
// within the configuration MUST be non-nil for the FundingManager to carry out
|
|
||||||
// its duties.
|
|
||||||
type fundingConfig struct {
|
|
||||||
// NoWumboChans indicates if we're to reject all incoming wumbo channel
|
|
||||||
// requests, and also reject all outgoing wumbo channel requests.
|
|
||||||
NoWumboChans bool
|
|
||||||
|
|
||||||
// IDKey is the PublicKey that is used to identify this node within the
|
|
||||||
// Lightning Network.
|
|
||||||
IDKey *btcec.PublicKey
|
|
||||||
|
|
||||||
// Wallet handles the parts of the funding process that involves moving
|
|
||||||
// funds from on-chain transaction outputs into Lightning channels.
|
|
||||||
Wallet *lnwallet.LightningWallet
|
|
||||||
|
|
||||||
// PublishTransaction facilitates the process of broadcasting a
|
|
||||||
// transaction to the network.
|
|
||||||
PublishTransaction func(*wire.MsgTx, string) error
|
|
||||||
|
|
||||||
// UpdateLabel updates the label that a transaction has in our wallet,
|
|
||||||
// overwriting any existing labels.
|
|
||||||
UpdateLabel func(chainhash.Hash, string) error
|
|
||||||
|
|
||||||
// FeeEstimator calculates appropriate fee rates based on historical
|
|
||||||
// transaction information.
|
|
||||||
FeeEstimator chainfee.Estimator
|
|
||||||
|
|
||||||
// Notifier is used by the FundingManager to determine when the
|
|
||||||
// channel's funding transaction has been confirmed on the blockchain
|
|
||||||
// so that the channel creation process can be completed.
|
|
||||||
Notifier chainntnfs.ChainNotifier
|
|
||||||
|
|
||||||
// SignMessage signs an arbitrary message with a given public key. The
|
|
||||||
// actual digest signed is the double sha-256 of the message. In the
|
|
||||||
// case that the private key corresponding to the passed public key
|
|
||||||
// cannot be located, then an error is returned.
|
|
||||||
//
|
|
||||||
// TODO(roasbeef): should instead pass on this responsibility to a
|
|
||||||
// distinct sub-system?
|
|
||||||
SignMessage func(pubKey *btcec.PublicKey,
|
|
||||||
msg []byte) (input.Signature, error)
|
|
||||||
|
|
||||||
// CurrentNodeAnnouncement should return the latest, fully signed node
|
|
||||||
// announcement from the backing Lightning Network node.
|
|
||||||
CurrentNodeAnnouncement func() (lnwire.NodeAnnouncement, error)
|
|
||||||
|
|
||||||
// SendAnnouncement is used by the FundingManager to send announcement
|
|
||||||
// messages to the Gossiper to possibly broadcast to the greater
|
|
||||||
// network. A set of optional message fields can be provided to populate
|
|
||||||
// any information within the graph that is not included in the gossip
|
|
||||||
// message.
|
|
||||||
SendAnnouncement func(msg lnwire.Message,
|
|
||||||
optionalFields ...discovery.OptionalMsgField) chan error
|
|
||||||
|
|
||||||
// NotifyWhenOnline allows the FundingManager to register with a
|
|
||||||
// subsystem that will notify it when the peer comes online. This is
|
|
||||||
// used when sending the fundingLocked message, since it MUST be
|
|
||||||
// delivered after the funding transaction is confirmed.
|
|
||||||
//
|
|
||||||
// NOTE: The peerChan channel must be buffered.
|
|
||||||
NotifyWhenOnline func(peer [33]byte, peerChan chan<- lnpeer.Peer)
|
|
||||||
|
|
||||||
// FindChannel queries the database for the channel with the given
|
|
||||||
// channel ID.
|
|
||||||
FindChannel func(chanID lnwire.ChannelID) (*channeldb.OpenChannel, error)
|
|
||||||
|
|
||||||
// TempChanIDSeed is a cryptographically random string of bytes that's
|
|
||||||
// used as a seed to generate pending channel ID's.
|
|
||||||
TempChanIDSeed [32]byte
|
|
||||||
|
|
||||||
// DefaultRoutingPolicy is the default routing policy used when
|
|
||||||
// initially announcing channels.
|
|
||||||
DefaultRoutingPolicy htlcswitch.ForwardingPolicy
|
|
||||||
|
|
||||||
// DefaultMinHtlcIn is the default minimum incoming htlc value that is
|
|
||||||
// set as a channel parameter.
|
|
||||||
DefaultMinHtlcIn lnwire.MilliSatoshi
|
|
||||||
|
|
||||||
// NumRequiredConfs is a function closure that helps the funding
|
|
||||||
// manager decide how many confirmations it should require for a
|
|
||||||
// channel extended to it. The function is able to take into account
|
|
||||||
// the amount of the channel, and any funds we'll be pushed in the
|
|
||||||
// process to determine how many confirmations we'll require.
|
|
||||||
NumRequiredConfs func(btcutil.Amount, lnwire.MilliSatoshi) uint16
|
|
||||||
|
|
||||||
// RequiredRemoteDelay is a function that maps the total amount in a
|
|
||||||
// proposed channel to the CSV delay that we'll require for the remote
|
|
||||||
// party. Naturally a larger channel should require a higher CSV delay
|
|
||||||
// in order to give us more time to claim funds in the case of a
|
|
||||||
// contract breach.
|
|
||||||
RequiredRemoteDelay func(btcutil.Amount) uint16
|
|
||||||
|
|
||||||
// RequiredRemoteChanReserve is a function closure that, given the
|
|
||||||
// channel capacity and dust limit, will return an appropriate amount
|
|
||||||
// for the remote peer's required channel reserve that is to be adhered
|
|
||||||
// to at all times.
|
|
||||||
RequiredRemoteChanReserve func(capacity, dustLimit btcutil.Amount) btcutil.Amount
|
|
||||||
|
|
||||||
// RequiredRemoteMaxValue is a function closure that, given the channel
|
|
||||||
// capacity, returns the amount of MilliSatoshis that our remote peer
|
|
||||||
// can have in total outstanding HTLCs with us.
|
|
||||||
RequiredRemoteMaxValue func(btcutil.Amount) lnwire.MilliSatoshi
|
|
||||||
|
|
||||||
// RequiredRemoteMaxHTLCs is a function closure that, given the channel
|
|
||||||
// capacity, returns the number of maximum HTLCs the remote peer can
|
|
||||||
// offer us.
|
|
||||||
RequiredRemoteMaxHTLCs func(btcutil.Amount) uint16
|
|
||||||
|
|
||||||
// WatchNewChannel is to be called once a new channel enters the final
|
|
||||||
// funding stage: waiting for on-chain confirmation. This method sends
|
|
||||||
// the channel to the ChainArbitrator so it can watch for any on-chain
|
|
||||||
// events related to the channel. We also provide the public key of the
|
|
||||||
// node we're establishing a channel with for reconnection purposes.
|
|
||||||
WatchNewChannel func(*channeldb.OpenChannel, *btcec.PublicKey) error
|
|
||||||
|
|
||||||
// ReportShortChanID allows the funding manager to report the newly
|
|
||||||
// discovered short channel ID of a formerly pending channel to outside
|
|
||||||
// sub-systems.
|
|
||||||
ReportShortChanID func(wire.OutPoint) error
|
|
||||||
|
|
||||||
// ZombieSweeperInterval is the periodic time interval in which the
|
|
||||||
// zombie sweeper is run.
|
|
||||||
ZombieSweeperInterval time.Duration
|
|
||||||
|
|
||||||
// ReservationTimeout is the length of idle time that must pass before
|
|
||||||
// a reservation is considered a zombie.
|
|
||||||
ReservationTimeout time.Duration
|
|
||||||
|
|
||||||
// MinChanSize is the smallest channel size that we'll accept as an
|
|
||||||
// inbound channel. We have such a parameter, as otherwise, nodes could
|
|
||||||
// flood us with very small channels that would never really be usable
|
|
||||||
// due to fees.
|
|
||||||
MinChanSize btcutil.Amount
|
|
||||||
|
|
||||||
// MaxChanSize is the largest channel size that we'll accept as an
|
|
||||||
// inbound channel. We have such a parameter, so that you may decide how
|
|
||||||
// WUMBO you would like your channel.
|
|
||||||
MaxChanSize btcutil.Amount
|
|
||||||
|
|
||||||
// MaxPendingChannels is the maximum number of pending channels we
|
|
||||||
// allow for each peer.
|
|
||||||
MaxPendingChannels int
|
|
||||||
|
|
||||||
// RejectPush is set true if the fundingmanager should reject any
|
|
||||||
// incoming channels having a non-zero push amount.
|
|
||||||
RejectPush bool
|
|
||||||
|
|
||||||
// MaxLocalCSVDelay is the maximum csv delay we will allow for our
|
|
||||||
// commit output. Channels that exceed this value will be failed.
|
|
||||||
MaxLocalCSVDelay uint16
|
|
||||||
|
|
||||||
// NotifyOpenChannelEvent informs the ChannelNotifier when channels
|
|
||||||
// transition from pending open to open.
|
|
||||||
NotifyOpenChannelEvent func(wire.OutPoint)
|
|
||||||
|
|
||||||
// OpenChannelPredicate is a predicate on the lnwire.OpenChannel message
|
|
||||||
// and on the requesting node's public key that returns a bool which tells
|
|
||||||
// the funding manager whether or not to accept the channel.
|
|
||||||
OpenChannelPredicate chanacceptor.ChannelAcceptor
|
|
||||||
|
|
||||||
// NotifyPendingOpenChannelEvent informs the ChannelNotifier when channels
|
|
||||||
// enter a pending state.
|
|
||||||
NotifyPendingOpenChannelEvent func(wire.OutPoint, *channeldb.OpenChannel)
|
|
||||||
|
|
||||||
// EnableUpfrontShutdown specifies whether the upfront shutdown script
|
|
||||||
// is enabled.
|
|
||||||
EnableUpfrontShutdown bool
|
|
||||||
|
|
||||||
// RegisteredChains keeps track of all chains that have been registered
|
|
||||||
// with the daemon.
|
|
||||||
RegisteredChains *chainreg.ChainRegistry
|
|
||||||
|
|
||||||
// MaxAnchorsCommitFeeRate is the max commitment fee rate we'll use as
|
|
||||||
// the initiator for channels of the anchor type.
|
|
||||||
MaxAnchorsCommitFeeRate chainfee.SatPerKWeight
|
|
||||||
}
|
|
||||||
|
|
||||||
// Manager acts as an orchestrator/bridge between the wallet's
|
|
||||||
// 'ChannelReservation' workflow, and the wire protocol's funding initiation
|
|
||||||
// messages. Any requests to initiate the funding workflow for a channel,
|
|
||||||
// either kicked-off locally or remotely are handled by the funding manager.
|
|
||||||
// Once a channel's funding workflow has been completed, any local callers, the
|
|
||||||
// local peer, and possibly the remote peer are notified of the completion of
|
|
||||||
// the channel workflow. Additionally, any temporary or permanent access
|
|
||||||
// controls between the wallet and remote peers are enforced via the funding
|
|
||||||
// manager.
|
|
||||||
type Manager struct {
|
|
||||||
started sync.Once
|
|
||||||
stopped sync.Once
|
|
||||||
|
|
||||||
// cfg is a copy of the configuration struct that the FundingManager
|
|
||||||
// was initialized with.
|
|
||||||
cfg *fundingConfig
|
|
||||||
|
|
||||||
// chanIDKey is a cryptographically random key that's used to generate
|
|
||||||
// temporary channel ID's.
|
|
||||||
chanIDKey [32]byte
|
|
||||||
|
|
||||||
// chanIDNonce is a nonce that's incremented for each new funding
|
|
||||||
// reservation created.
|
|
||||||
nonceMtx sync.RWMutex
|
|
||||||
chanIDNonce uint64
|
|
||||||
|
|
||||||
// activeReservations is a map which houses the state of all pending
|
|
||||||
// funding workflows.
|
|
||||||
activeReservations map[serializedPubKey]pendingChannels
|
|
||||||
|
|
||||||
// signedReservations is a utility map that maps the permanent channel
|
|
||||||
// ID of a funding reservation to its temporary channel ID. This is
|
|
||||||
// required as mid funding flow, we switch to referencing the channel
|
|
||||||
// by its full channel ID once the commitment transactions have been
|
|
||||||
// signed by both parties.
|
|
||||||
signedReservations map[lnwire.ChannelID][32]byte
|
|
||||||
|
|
||||||
// resMtx guards both of the maps above to ensure that all access is
|
|
||||||
// goroutine safe.
|
|
||||||
resMtx sync.RWMutex
|
|
||||||
|
|
||||||
// fundingMsgs is a channel that relays fundingMsg structs from
|
|
||||||
// external sub-systems using the ProcessFundingMsg call.
|
|
||||||
fundingMsgs chan *fundingMsg
|
|
||||||
|
|
||||||
// fundingRequests is a channel used to receive channel initiation
|
|
||||||
// requests from a local subsystem within the daemon.
|
|
||||||
fundingRequests chan *InitFundingMsg
|
|
||||||
|
|
||||||
// newChanBarriers is a map from a channel ID to a 'barrier' which will
|
|
||||||
// be signalled once the channel is fully open. This barrier acts as a
|
|
||||||
// synchronization point for any incoming/outgoing HTLCs before the
|
|
||||||
// channel has been fully opened.
|
|
||||||
barrierMtx sync.RWMutex
|
|
||||||
newChanBarriers map[lnwire.ChannelID]chan struct{}
|
|
||||||
|
|
||||||
localDiscoveryMtx sync.Mutex
|
|
||||||
localDiscoverySignals map[lnwire.ChannelID]chan struct{}
|
|
||||||
|
|
||||||
handleFundingLockedMtx sync.RWMutex
|
|
||||||
handleFundingLockedBarriers map[lnwire.ChannelID]struct{}
|
|
||||||
|
|
||||||
quit chan struct{}
|
|
||||||
wg sync.WaitGroup
|
|
||||||
}
|
|
||||||
|
|
||||||
// channelOpeningState represents the different states a channel can be in
|
|
||||||
// between the funding transaction has been confirmed and the channel is
|
|
||||||
// announced to the network and ready to be used.
|
|
||||||
type channelOpeningState uint8
|
|
||||||
|
|
||||||
const (
|
|
||||||
// markedOpen is the opening state of a channel if the funding
|
|
||||||
// transaction is confirmed on-chain, but fundingLocked is not yet
|
|
||||||
// successfully sent to the other peer.
|
|
||||||
markedOpen channelOpeningState = iota
|
|
||||||
|
|
||||||
// fundingLockedSent is the opening state of a channel if the
|
|
||||||
// fundingLocked message has successfully been sent to the other peer,
|
|
||||||
// but we still haven't announced the channel to the network.
|
|
||||||
fundingLockedSent
|
|
||||||
|
|
||||||
// addedToRouterGraph is the opening state of a channel if the
|
|
||||||
// channel has been successfully added to the router graph
|
|
||||||
// immediately after the fundingLocked message has been sent, but
|
|
||||||
// we still haven't announced the channel to the network.
|
|
||||||
addedToRouterGraph
|
|
||||||
)
|
|
||||||
|
|
||||||
var (
|
|
||||||
// channelOpeningStateBucket is the database bucket used to store the
|
|
||||||
// channelOpeningState for each channel that is currently in the process
|
|
||||||
// of being opened.
|
|
||||||
channelOpeningStateBucket = []byte("channelOpeningState")
|
|
||||||
|
|
||||||
// ErrChannelNotFound is an error returned when a channel is not known
|
|
||||||
// to us. In this case of the fundingManager, this error is returned
|
|
||||||
// when the channel in question is not considered being in an opening
|
|
||||||
// state.
|
|
||||||
ErrChannelNotFound = fmt.Errorf("channel not found")
|
|
||||||
)
|
|
||||||
|
|
||||||
// NewFundingManager creates and initializes a new instance of the
|
|
||||||
// fundingManager.
|
|
||||||
func NewFundingManager(cfg fundingConfig) (*Manager, error) {
|
|
||||||
return &Manager{
|
|
||||||
cfg: &cfg,
|
|
||||||
chanIDKey: cfg.TempChanIDSeed,
|
|
||||||
activeReservations: make(map[serializedPubKey]pendingChannels),
|
|
||||||
signedReservations: make(map[lnwire.ChannelID][32]byte),
|
|
||||||
newChanBarriers: make(map[lnwire.ChannelID]chan struct{}),
|
|
||||||
fundingMsgs: make(chan *fundingMsg, msgBufferSize),
|
|
||||||
fundingRequests: make(chan *InitFundingMsg, msgBufferSize),
|
|
||||||
localDiscoverySignals: make(map[lnwire.ChannelID]chan struct{}),
|
|
||||||
handleFundingLockedBarriers: make(map[lnwire.ChannelID]struct{}),
|
|
||||||
quit: make(chan struct{}),
|
|
||||||
}, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Start launches all helper goroutines required for handling requests sent
|
|
||||||
// to the funding manager.
|
|
||||||
func (f *Manager) Start() error {
|
|
||||||
var err error
|
|
||||||
f.started.Do(func() {
|
|
||||||
err = f.start()
|
|
||||||
})
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
func (f *Manager) start() error {
|
|
||||||
fndgLog.Tracef("Funding manager running")
|
|
||||||
|
|
||||||
// Upon restart, the Funding Manager will check the database to load any
|
|
||||||
// channels that were waiting for their funding transactions to be
|
|
||||||
// confirmed on the blockchain at the time when the daemon last went
|
|
||||||
// down.
|
|
||||||
// TODO(roasbeef): store height that funding finished?
|
|
||||||
// * would then replace call below
|
|
||||||
allChannels, err := f.cfg.Wallet.Cfg.Database.FetchAllChannels()
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, channel := range allChannels {
|
|
||||||
chanID := lnwire.NewChanIDFromOutPoint(&channel.FundingOutpoint)
|
|
||||||
|
|
||||||
// For any channels that were in a pending state when the
|
|
||||||
// daemon was last connected, the Funding Manager will
|
|
||||||
// re-initialize the channel barriers, and republish the
|
|
||||||
// funding transaction if we're the initiator.
|
|
||||||
if channel.IsPending {
|
|
||||||
f.barrierMtx.Lock()
|
|
||||||
fndgLog.Tracef("Loading pending ChannelPoint(%v), "+
|
|
||||||
"creating chan barrier",
|
|
||||||
channel.FundingOutpoint)
|
|
||||||
|
|
||||||
f.newChanBarriers[chanID] = make(chan struct{})
|
|
||||||
f.barrierMtx.Unlock()
|
|
||||||
|
|
||||||
f.localDiscoverySignals[chanID] = make(chan struct{})
|
|
||||||
|
|
||||||
// Rebroadcast the funding transaction for any pending
|
|
||||||
// channel that we initiated. No error will be returned
|
|
||||||
// if the transaction already has been broadcast.
|
|
||||||
chanType := channel.ChanType
|
|
||||||
if chanType.IsSingleFunder() && chanType.HasFundingTx() &&
|
|
||||||
channel.IsInitiator {
|
|
||||||
|
|
||||||
var fundingTxBuf bytes.Buffer
|
|
||||||
err := channel.FundingTxn.Serialize(&fundingTxBuf)
|
|
||||||
if err != nil {
|
|
||||||
fndgLog.Errorf("Unable to serialize "+
|
|
||||||
"funding transaction %v: %v",
|
|
||||||
channel.FundingTxn.TxHash(), err)
|
|
||||||
|
|
||||||
// Clear the buffer of any bytes that
|
|
||||||
// were written before the serialization
|
|
||||||
// error to prevent logging an
|
|
||||||
// incomplete transaction.
|
|
||||||
fundingTxBuf.Reset()
|
|
||||||
}
|
|
||||||
|
|
||||||
fndgLog.Debugf("Rebroadcasting funding tx for "+
|
|
||||||
"ChannelPoint(%v): %x",
|
|
||||||
channel.FundingOutpoint,
|
|
||||||
fundingTxBuf.Bytes())
|
|
||||||
|
|
||||||
// Set a nil short channel ID at this stage
|
|
||||||
// because we do not know it until our funding
|
|
||||||
// tx confirms.
|
|
||||||
label := labels.MakeLabel(
|
|
||||||
labels.LabelTypeChannelOpen, nil,
|
|
||||||
)
|
|
||||||
|
|
||||||
err = f.cfg.PublishTransaction(
|
|
||||||
channel.FundingTxn, label,
|
|
||||||
)
|
|
||||||
if err != nil {
|
|
||||||
fndgLog.Errorf("Unable to rebroadcast "+
|
|
||||||
"funding tx %x for "+
|
|
||||||
"ChannelPoint(%v): %v",
|
|
||||||
fundingTxBuf.Bytes(),
|
|
||||||
channel.FundingOutpoint, err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// We will restart the funding state machine for all channels,
|
|
||||||
// which will wait for the channel's funding transaction to be
|
|
||||||
// confirmed on the blockchain, and transmit the messages
|
|
||||||
// necessary for the channel to be operational.
|
|
||||||
f.wg.Add(1)
|
|
||||||
go f.advanceFundingState(channel, chanID, nil)
|
|
||||||
}
|
|
||||||
|
|
||||||
f.wg.Add(1) // TODO(roasbeef): tune
|
|
||||||
go f.reservationCoordinator()
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// Stop signals all helper goroutines to execute a graceful shutdown. This
|
|
||||||
// method will block until all goroutines have exited.
|
|
||||||
func (f *Manager) Stop() {
|
|
||||||
f.stopped.Do(func() {
|
|
||||||
fndgLog.Info("Funding manager shutting down")
|
|
||||||
close(f.quit)
|
|
||||||
f.wg.Wait()
|
|
||||||
})
|
|
||||||
}
|
|
||||||
|
|
||||||
// nextPendingChanID returns the next free pending channel ID to be used to
|
|
||||||
// identify a particular future channel funding workflow.
|
|
||||||
func (f *Manager) nextPendingChanID() [32]byte {
|
|
||||||
// Obtain a fresh nonce. We do this by encoding the current nonce
|
|
||||||
// counter, then incrementing it by one.
|
|
||||||
f.nonceMtx.Lock()
|
|
||||||
var nonce [8]byte
|
|
||||||
binary.LittleEndian.PutUint64(nonce[:], f.chanIDNonce)
|
|
||||||
f.chanIDNonce++
|
|
||||||
f.nonceMtx.Unlock()
|
|
||||||
|
|
||||||
// We'll generate the next pending channelID by "encrypting" 32-bytes
|
|
||||||
// of zeroes which'll extract 32 random bytes from our stream cipher.
|
|
||||||
var (
|
|
||||||
nextChanID [32]byte
|
|
||||||
zeroes [32]byte
|
|
||||||
)
|
|
||||||
salsa20.XORKeyStream(nextChanID[:], zeroes[:], nonce[:], &f.chanIDKey)
|
|
||||||
|
|
||||||
return nextChanID
|
|
||||||
}
|
|
||||||
|
|
||||||
// CancelPeerReservations cancels all active reservations associated with the
|
|
||||||
// passed node. This will ensure any outputs which have been pre committed,
|
|
||||||
// (and thus locked from coin selection), are properly freed.
|
|
||||||
func (f *Manager) CancelPeerReservations(nodePub [33]byte) {
|
|
||||||
|
|
||||||
fndgLog.Debugf("Cancelling all reservations for peer %x", nodePub[:])
|
|
||||||
|
|
||||||
f.resMtx.Lock()
|
|
||||||
defer f.resMtx.Unlock()
|
|
||||||
|
|
||||||
// We'll attempt to look up this node in the set of active
|
|
||||||
// reservations. If they don't have any, then there's no further work
|
|
||||||
// to be done.
|
|
||||||
nodeReservations, ok := f.activeReservations[nodePub]
|
|
||||||
if !ok {
|
|
||||||
fndgLog.Debugf("No active reservations for node: %x", nodePub[:])
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// If they do have any active reservations, then we'll cancel all of
|
|
||||||
// them (which releases any locked UTXO's), and also delete it from the
|
|
||||||
// reservation map.
|
|
||||||
for pendingID, resCtx := range nodeReservations {
|
|
||||||
if err := resCtx.reservation.Cancel(); err != nil {
|
|
||||||
fndgLog.Errorf("unable to cancel reservation for "+
|
|
||||||
"node=%x: %v", nodePub[:], err)
|
|
||||||
}
|
|
||||||
|
|
||||||
resCtx.err <- fmt.Errorf("peer disconnected")
|
|
||||||
delete(nodeReservations, pendingID)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Finally, we'll delete the node itself from the set of reservations.
|
|
||||||
delete(f.activeReservations, nodePub)
|
|
||||||
}
|
|
||||||
|
|
||||||
// failFundingFlow will fail the active funding flow with the target peer,
|
|
||||||
// identified by its unique temporary channel ID. This method will send an
|
|
||||||
// error to the remote peer, and also remove the reservation from our set of
|
|
||||||
// pending reservations.
|
|
||||||
//
|
|
||||||
// TODO(roasbeef): if peer disconnects, and haven't yet broadcast funding
|
|
||||||
// transaction, then all reservations should be cleared.
|
|
||||||
func (f *Manager) failFundingFlow(peer lnpeer.Peer, tempChanID [32]byte,
|
|
||||||
fundingErr error) {
|
|
||||||
|
|
||||||
fndgLog.Debugf("Failing funding flow for pending_id=%x: %v",
|
|
||||||
tempChanID, fundingErr)
|
|
||||||
|
|
||||||
ctx, err := f.cancelReservationCtx(peer.IdentityKey(), tempChanID, false)
|
|
||||||
if err != nil {
|
|
||||||
fndgLog.Errorf("unable to cancel reservation: %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// In case the case where the reservation existed, send the funding
|
|
||||||
// error on the error channel.
|
|
||||||
if ctx != nil {
|
|
||||||
ctx.err <- fundingErr
|
|
||||||
}
|
|
||||||
|
|
||||||
// We only send the exact error if it is part of out whitelisted set of
|
|
||||||
// errors (lnwire.FundingError or lnwallet.ReservationError).
|
|
||||||
var msg lnwire.ErrorData
|
|
||||||
switch e := fundingErr.(type) {
|
|
||||||
|
|
||||||
// Let the actual error message be sent to the remote for the
|
|
||||||
// whitelisted types.
|
|
||||||
case lnwallet.ReservationError:
|
|
||||||
msg = lnwire.ErrorData(e.Error())
|
|
||||||
case lnwire.FundingError:
|
|
||||||
msg = lnwire.ErrorData(e.Error())
|
|
||||||
case chanacceptor.ChanAcceptError:
|
|
||||||
msg = lnwire.ErrorData(e.Error())
|
|
||||||
|
|
||||||
// For all other error types we just send a generic error.
|
|
||||||
default:
|
|
||||||
msg = lnwire.ErrorData("funding failed due to internal error")
|
|
||||||
}
|
|
||||||
|
|
||||||
errMsg := &lnwire.Error{
|
|
||||||
ChanID: tempChanID,
|
|
||||||
Data: msg,
|
|
||||||
}
|
|
||||||
|
|
||||||
fndgLog.Debugf("Sending funding error to peer (%x): %v",
|
|
||||||
peer.IdentityKey().SerializeCompressed(), spew.Sdump(errMsg))
|
|
||||||
if err := peer.SendMessage(false, errMsg); err != nil {
|
|
||||||
fndgLog.Errorf("unable to send error message to peer %v", err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// reservationCoordinator is the primary goroutine tasked with progressing the
|
|
||||||
// funding workflow between the wallet, and any outside peers or local callers.
|
|
||||||
//
|
|
||||||
// NOTE: This MUST be run as a goroutine.
|
|
||||||
func (f *Manager) reservationCoordinator() {
|
|
||||||
defer f.wg.Done()
|
|
||||||
|
|
||||||
zombieSweepTicker := time.NewTicker(f.cfg.ZombieSweeperInterval)
|
|
||||||
defer zombieSweepTicker.Stop()
|
|
||||||
|
|
||||||
for {
|
|
||||||
select {
|
|
||||||
|
|
||||||
case fmsg := <-f.fundingMsgs:
|
|
||||||
switch msg := fmsg.msg.(type) {
|
|
||||||
case *lnwire.OpenChannel:
|
|
||||||
f.handleFundingOpen(fmsg.peer, msg)
|
|
||||||
case *lnwire.AcceptChannel:
|
|
||||||
f.handleFundingAccept(fmsg.peer, msg)
|
|
||||||
case *lnwire.FundingCreated:
|
|
||||||
f.handleFundingCreated(fmsg.peer, msg)
|
|
||||||
case *lnwire.FundingSigned:
|
|
||||||
f.handleFundingSigned(fmsg.peer, msg)
|
|
||||||
case *lnwire.FundingLocked:
|
|
||||||
f.wg.Add(1)
|
|
||||||
go f.handleFundingLocked(fmsg.peer, msg)
|
|
||||||
case *lnwire.Error:
|
|
||||||
f.handleErrorMsg(fmsg.peer, msg)
|
|
||||||
}
|
|
||||||
case req := <-f.fundingRequests:
|
|
||||||
f.handleInitFundingMsg(req)
|
|
||||||
|
|
||||||
case <-zombieSweepTicker.C:
|
|
||||||
f.pruneZombieReservations()
|
|
||||||
|
|
||||||
case <-f.quit:
|
|
||||||
return
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// advanceFundingState will advance the channel through the steps after the
|
|
||||||
// funding transaction is broadcasted, up until the point where the channel is
|
|
||||||
// ready for operation. This includes waiting for the funding transaction to
|
|
||||||
// confirm, sending funding locked to the peer, adding the channel to the
|
|
||||||
// router graph, and announcing the channel. The updateChan can be set non-nil
|
|
||||||
// to get OpenStatusUpdates.
|
|
||||||
//
|
|
||||||
// NOTE: This MUST be run as a goroutine.
|
|
||||||
func (f *Manager) advanceFundingState(channel *channeldb.OpenChannel,
|
|
||||||
pendingChanID [32]byte, updateChan chan<- *lnrpc.OpenStatusUpdate) {
|
|
||||||
|
|
||||||
defer f.wg.Done()
|
|
||||||
|
|
||||||
// If the channel is still pending we must wait for the funding
|
|
||||||
// transaction to confirm.
|
|
||||||
if channel.IsPending {
|
|
||||||
err := f.advancePendingChannelState(channel, pendingChanID)
|
|
||||||
if err != nil {
|
|
||||||
fndgLog.Errorf("Unable to advance pending state of "+
|
|
||||||
"ChannelPoint(%v): %v",
|
|
||||||
channel.FundingOutpoint, err)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// We create the state-machine object which wraps the database state.
|
|
||||||
lnChannel, err := lnwallet.NewLightningChannel(
|
|
||||||
nil, channel, nil,
|
|
||||||
)
|
|
||||||
if err != nil {
|
|
||||||
fndgLog.Errorf("Unable to create LightningChannel(%v): %v",
|
|
||||||
channel.FundingOutpoint, err)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
for {
|
|
||||||
channelState, shortChanID, err := f.getChannelOpeningState(
|
|
||||||
&channel.FundingOutpoint,
|
|
||||||
)
|
|
||||||
if err == ErrChannelNotFound {
|
|
||||||
// Channel not in fundingManager's opening database,
|
|
||||||
// meaning it was successfully announced to the
|
|
||||||
// network.
|
|
||||||
// TODO(halseth): could do graph consistency check
|
|
||||||
// here, and re-add the edge if missing.
|
|
||||||
fndgLog.Debugf("ChannelPoint(%v) with chan_id=%x not "+
|
|
||||||
"found in opening database, assuming already "+
|
|
||||||
"announced to the network",
|
|
||||||
channel.FundingOutpoint, pendingChanID)
|
|
||||||
return
|
|
||||||
} else if err != nil {
|
|
||||||
fndgLog.Errorf("Unable to query database for "+
|
|
||||||
"channel opening state(%v): %v",
|
|
||||||
channel.FundingOutpoint, err)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// If we did find the channel in the opening state database, we
|
|
||||||
// have seen the funding transaction being confirmed, but there
|
|
||||||
// are still steps left of the setup procedure. We continue the
|
|
||||||
// procedure where we left off.
|
|
||||||
err = f.stateStep(
|
|
||||||
channel, lnChannel, shortChanID, pendingChanID,
|
|
||||||
channelState, updateChan,
|
|
||||||
)
|
|
||||||
if err != nil {
|
|
||||||
fndgLog.Errorf("Unable to advance state(%v): %v",
|
|
||||||
channel.FundingOutpoint, err)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// stateStep advances the confirmed channel one step in the funding state
|
|
||||||
// machine. This method is synchronous and the new channel opening state will
|
|
||||||
// have been written to the database when it successfully returns. The
|
|
||||||
// updateChan can be set non-nil to get OpenStatusUpdates.
|
|
||||||
func (f *Manager) stateStep(channel *channeldb.OpenChannel,
|
|
||||||
lnChannel *lnwallet.LightningChannel,
|
|
||||||
shortChanID *lnwire.ShortChannelID, pendingChanID [32]byte,
|
|
||||||
channelState channelOpeningState,
|
|
||||||
updateChan chan<- *lnrpc.OpenStatusUpdate) error {
|
|
||||||
|
|
||||||
chanID := lnwire.NewChanIDFromOutPoint(&channel.FundingOutpoint)
|
|
||||||
fndgLog.Debugf("Channel(%v) with ShortChanID %v has opening state %v",
|
|
||||||
chanID, shortChanID, channelState)
|
|
||||||
|
|
||||||
switch channelState {
|
|
||||||
|
|
||||||
// The funding transaction was confirmed, but we did not successfully
|
|
||||||
// send the fundingLocked message to the peer, so let's do that now.
|
|
||||||
case markedOpen:
|
|
||||||
err := f.sendFundingLocked(channel, lnChannel, shortChanID)
|
|
||||||
if err != nil {
|
|
||||||
return fmt.Errorf("failed sending fundingLocked: %v",
|
|
||||||
err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// As the fundingLocked message is now sent to the peer, the
|
|
||||||
// channel is moved to the next state of the state machine. It
|
|
||||||
// will be moved to the last state (actually deleted from the
|
|
||||||
// database) after the channel is finally announced.
|
|
||||||
err = f.saveChannelOpeningState(
|
|
||||||
&channel.FundingOutpoint, fundingLockedSent,
|
|
||||||
shortChanID,
|
|
||||||
)
|
|
||||||
if err != nil {
|
|
||||||
return fmt.Errorf("error setting channel state to"+
|
|
||||||
" fundingLockedSent: %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
fndgLog.Debugf("Channel(%v) with ShortChanID %v: successfully "+
|
|
||||||
"sent FundingLocked", chanID, shortChanID)
|
|
||||||
|
|
||||||
return nil
|
|
||||||
|
|
||||||
// fundingLocked was sent to peer, but the channel was not added to the
|
|
||||||
// router graph and the channel announcement was not sent.
|
|
||||||
case fundingLockedSent:
|
|
||||||
err := f.addToRouterGraph(channel, shortChanID)
|
|
||||||
if err != nil {
|
|
||||||
return fmt.Errorf("failed adding to "+
|
|
||||||
"router graph: %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// As the channel is now added to the ChannelRouter's topology,
|
|
||||||
// the channel is moved to the next state of the state machine.
|
|
||||||
// It will be moved to the last state (actually deleted from
|
|
||||||
// the database) after the channel is finally announced.
|
|
||||||
err = f.saveChannelOpeningState(
|
|
||||||
&channel.FundingOutpoint, addedToRouterGraph,
|
|
||||||
shortChanID,
|
|
||||||
)
|
|
||||||
if err != nil {
|
|
||||||
return fmt.Errorf("error setting channel state to"+
|
|
||||||
" addedToRouterGraph: %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
fndgLog.Debugf("Channel(%v) with ShortChanID %v: successfully "+
|
|
||||||
"added to router graph", chanID, shortChanID)
|
|
||||||
|
|
||||||
// Give the caller a final update notifying them that
|
|
||||||
// the channel is now open.
|
|
||||||
// TODO(roasbeef): only notify after recv of funding locked?
|
|
||||||
fundingPoint := channel.FundingOutpoint
|
|
||||||
cp := &lnrpc.ChannelPoint{
|
|
||||||
FundingTxid: &lnrpc.ChannelPoint_FundingTxidBytes{
|
|
||||||
FundingTxidBytes: fundingPoint.Hash[:],
|
|
||||||
},
|
|
||||||
OutputIndex: fundingPoint.Index,
|
|
||||||
}
|
|
||||||
|
|
||||||
if updateChan != nil {
|
|
||||||
upd := &lnrpc.OpenStatusUpdate{
|
|
||||||
Update: &lnrpc.OpenStatusUpdate_ChanOpen{
|
|
||||||
ChanOpen: &lnrpc.ChannelOpenUpdate{
|
|
||||||
ChannelPoint: cp,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
PendingChanId: pendingChanID[:],
|
|
||||||
}
|
|
||||||
|
|
||||||
select {
|
|
||||||
case updateChan <- upd:
|
|
||||||
case <-f.quit:
|
|
||||||
return ErrFundingManagerShuttingDown
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
|
|
||||||
// The channel was added to the Router's topology, but the channel
|
|
||||||
// announcement was not sent.
|
|
||||||
case addedToRouterGraph:
|
|
||||||
err := f.annAfterSixConfs(channel, shortChanID)
|
|
||||||
if err != nil {
|
|
||||||
return fmt.Errorf("error sending channel "+
|
|
||||||
"announcement: %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// We delete the channel opening state from our internal
|
|
||||||
// database as the opening process has succeeded. We can do
|
|
||||||
// this because we assume the AuthenticatedGossiper queues the
|
|
||||||
// announcement messages, and persists them in case of a daemon
|
|
||||||
// shutdown.
|
|
||||||
err = f.deleteChannelOpeningState(&channel.FundingOutpoint)
|
|
||||||
if err != nil {
|
|
||||||
return fmt.Errorf("error deleting channel state: %v",
|
|
||||||
err)
|
|
||||||
}
|
|
||||||
|
|
||||||
fndgLog.Debugf("Channel(%v) with ShortChanID %v: successfully "+
|
|
||||||
"announced", chanID, shortChanID)
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
return fmt.Errorf("undefined channelState: %v", channelState)
|
|
||||||
}
|
|
||||||
|
|
||||||
// advancePendingChannelState waits for a pending channel's funding tx to
|
|
||||||
// confirm, and marks it open in the database when that happens.
|
|
||||||
func (f *Manager) advancePendingChannelState(
|
|
||||||
channel *channeldb.OpenChannel, pendingChanID [32]byte) error {
|
|
||||||
|
|
||||||
confChannel, err := f.waitForFundingWithTimeout(channel)
|
|
||||||
if err == ErrConfirmationTimeout {
|
|
||||||
// We'll get a timeout if the number of blocks mined
|
|
||||||
// since the channel was initiated reaches
|
|
||||||
// maxWaitNumBlocksFundingConf and we are not the
|
|
||||||
// channel initiator.
|
|
||||||
ch := channel
|
|
||||||
localBalance := ch.LocalCommitment.LocalBalance.ToSatoshis()
|
|
||||||
closeInfo := &channeldb.ChannelCloseSummary{
|
|
||||||
ChainHash: ch.ChainHash,
|
|
||||||
ChanPoint: ch.FundingOutpoint,
|
|
||||||
RemotePub: ch.IdentityPub,
|
|
||||||
Capacity: ch.Capacity,
|
|
||||||
SettledBalance: localBalance,
|
|
||||||
CloseType: channeldb.FundingCanceled,
|
|
||||||
RemoteCurrentRevocation: ch.RemoteCurrentRevocation,
|
|
||||||
RemoteNextRevocation: ch.RemoteNextRevocation,
|
|
||||||
LocalChanConfig: ch.LocalChanCfg,
|
|
||||||
}
|
|
||||||
|
|
||||||
// Close the channel with us as the initiator because we are
|
|
||||||
// timing the channel out.
|
|
||||||
if err := ch.CloseChannel(
|
|
||||||
closeInfo, channeldb.ChanStatusLocalCloseInitiator,
|
|
||||||
); err != nil {
|
|
||||||
return fmt.Errorf("failed closing channel "+
|
|
||||||
"%v: %v", ch.FundingOutpoint, err)
|
|
||||||
}
|
|
||||||
|
|
||||||
timeoutErr := fmt.Errorf("timeout waiting for funding tx "+
|
|
||||||
"(%v) to confirm", channel.FundingOutpoint)
|
|
||||||
|
|
||||||
// When the peer comes online, we'll notify it that we
|
|
||||||
// are now considering the channel flow canceled.
|
|
||||||
f.wg.Add(1)
|
|
||||||
go func() {
|
|
||||||
defer f.wg.Done()
|
|
||||||
|
|
||||||
peerChan := make(chan lnpeer.Peer, 1)
|
|
||||||
var peerKey [33]byte
|
|
||||||
copy(peerKey[:], ch.IdentityPub.SerializeCompressed())
|
|
||||||
|
|
||||||
f.cfg.NotifyWhenOnline(peerKey, peerChan)
|
|
||||||
|
|
||||||
var peer lnpeer.Peer
|
|
||||||
select {
|
|
||||||
case peer = <-peerChan:
|
|
||||||
case <-f.quit:
|
|
||||||
return
|
|
||||||
}
|
|
||||||
// TODO(halseth): should this send be made
|
|
||||||
// reliable?
|
|
||||||
f.failFundingFlow(peer, pendingChanID, timeoutErr)
|
|
||||||
}()
|
|
||||||
|
|
||||||
return timeoutErr
|
|
||||||
|
|
||||||
} else if err != nil {
|
|
||||||
return fmt.Errorf("error waiting for funding "+
|
|
||||||
"confirmation for ChannelPoint(%v): %v",
|
|
||||||
channel.FundingOutpoint, err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Success, funding transaction was confirmed.
|
|
||||||
chanID := lnwire.NewChanIDFromOutPoint(&channel.FundingOutpoint)
|
|
||||||
fndgLog.Debugf("ChannelID(%v) is now fully confirmed! "+
|
|
||||||
"(shortChanID=%v)", chanID, confChannel.shortChanID)
|
|
||||||
|
|
||||||
err = f.handleFundingConfirmation(channel, confChannel)
|
|
||||||
if err != nil {
|
|
||||||
return fmt.Errorf("unable to handle funding "+
|
|
||||||
"confirmation for ChannelPoint(%v): %v",
|
|
||||||
channel.FundingOutpoint, err)
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// ProcessFundingMsg sends a message to the internal fundingManager goroutine,
|
|
||||||
// allowing it to handle the lnwire.Message.
|
|
||||||
func (f *Manager) ProcessFundingMsg(msg lnwire.Message, peer lnpeer.Peer) {
|
|
||||||
select {
|
|
||||||
case f.fundingMsgs <- &fundingMsg{msg, peer}:
|
|
||||||
case <-f.quit:
|
|
||||||
return
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// commitmentType returns the commitment type to use for the channel, based on
|
|
||||||
// the features the two peers have available.
|
|
||||||
func commitmentType(localFeatures,
|
|
||||||
remoteFeatures *lnwire.FeatureVector) lnwallet.CommitmentType {
|
|
||||||
|
|
||||||
// If both peers are signalling support for anchor commitments with
|
|
||||||
// zero-fee HTLC transactions, we'll use this type.
|
|
||||||
localZeroFee := localFeatures.HasFeature(
|
|
||||||
lnwire.AnchorsZeroFeeHtlcTxOptional,
|
|
||||||
)
|
|
||||||
remoteZeroFee := remoteFeatures.HasFeature(
|
|
||||||
lnwire.AnchorsZeroFeeHtlcTxOptional,
|
|
||||||
)
|
|
||||||
if localZeroFee && remoteZeroFee {
|
|
||||||
return lnwallet.CommitmentTypeAnchorsZeroFeeHtlcTx
|
|
||||||
}
|
|
||||||
|
|
||||||
// Since we don't want to support the "legacy" anchor type, we will
|
|
||||||
// fall back to static remote key if the nodes don't support the zero
|
|
||||||
// fee HTLC tx anchor type.
|
|
||||||
localTweakless := localFeatures.HasFeature(
|
|
||||||
lnwire.StaticRemoteKeyOptional,
|
|
||||||
)
|
|
||||||
remoteTweakless := remoteFeatures.HasFeature(
|
|
||||||
lnwire.StaticRemoteKeyOptional,
|
|
||||||
)
|
|
||||||
|
|
||||||
// If both nodes are signaling the proper feature bit for tweakless
|
|
||||||
// copmmitments, we'll use that.
|
|
||||||
if localTweakless && remoteTweakless {
|
|
||||||
return lnwallet.CommitmentTypeTweakless
|
|
||||||
}
|
|
||||||
|
|
||||||
// Otherwise we'll fall back to the legacy type.
|
|
||||||
return lnwallet.CommitmentTypeLegacy
|
|
||||||
}
|
|
||||||
|
|
||||||
// handleFundingOpen creates an initial 'ChannelReservation' within the wallet,
|
|
||||||
// then responds to the source peer with an accept channel message progressing
|
|
||||||
// the funding workflow.
|
|
||||||
//
|
|
||||||
// TODO(roasbeef): add error chan to all, let channelManager handle
|
|
||||||
// error+propagate
|
|
||||||
func (f *Manager) handleFundingOpen(peer lnpeer.Peer,
|
|
||||||
msg *lnwire.OpenChannel) {
|
|
||||||
|
|
||||||
// Check number of pending channels to be smaller than maximum allowed
|
|
||||||
// number and send ErrorGeneric to remote peer if condition is
|
|
||||||
// violated.
|
|
||||||
peerPubKey := peer.IdentityKey()
|
|
||||||
peerIDKey := newSerializedKey(peerPubKey)
|
|
||||||
|
|
||||||
amt := msg.FundingAmount
|
|
||||||
|
|
||||||
// We get all pending channels for this peer. This is the list of the
|
|
||||||
// active reservations and the channels pending open in the database.
|
|
||||||
f.resMtx.RLock()
|
|
||||||
reservations := f.activeReservations[peerIDKey]
|
|
||||||
|
|
||||||
// We don't count reservations that were created from a canned funding
|
|
||||||
// shim. The user has registered the shim and therefore expects this
|
|
||||||
// channel to arrive.
|
|
||||||
numPending := 0
|
|
||||||
for _, res := range reservations {
|
|
||||||
if !res.reservation.IsCannedShim() {
|
|
||||||
numPending++
|
|
||||||
}
|
|
||||||
}
|
|
||||||
f.resMtx.RUnlock()
|
|
||||||
|
|
||||||
// Also count the channels that are already pending. There we don't know
|
|
||||||
// the underlying intent anymore, unfortunately.
|
|
||||||
channels, err := f.cfg.Wallet.Cfg.Database.FetchOpenChannels(peerPubKey)
|
|
||||||
if err != nil {
|
|
||||||
f.failFundingFlow(
|
|
||||||
peer, msg.PendingChannelID, err,
|
|
||||||
)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
for _, c := range channels {
|
|
||||||
// Pending channels that have a non-zero thaw height were also
|
|
||||||
// created through a canned funding shim. Those also don't
|
|
||||||
// count towards the DoS protection limit.
|
|
||||||
//
|
|
||||||
// TODO(guggero): Properly store the funding type (wallet, shim,
|
|
||||||
// PSBT) on the channel so we don't need to use the thaw height.
|
|
||||||
if c.IsPending && c.ThawHeight == 0 {
|
|
||||||
numPending++
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// TODO(roasbeef): modify to only accept a _single_ pending channel per
|
|
||||||
// block unless white listed
|
|
||||||
if numPending >= f.cfg.MaxPendingChannels {
|
|
||||||
f.failFundingFlow(
|
|
||||||
peer, msg.PendingChannelID,
|
|
||||||
lnwire.ErrMaxPendingChannels,
|
|
||||||
)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// We'll also reject any requests to create channels until we're fully
|
|
||||||
// synced to the network as we won't be able to properly validate the
|
|
||||||
// confirmation of the funding transaction.
|
|
||||||
isSynced, _, err := f.cfg.Wallet.IsSynced()
|
|
||||||
if err != nil || !isSynced {
|
|
||||||
if err != nil {
|
|
||||||
fndgLog.Errorf("unable to query wallet: %v", err)
|
|
||||||
}
|
|
||||||
f.failFundingFlow(
|
|
||||||
peer, msg.PendingChannelID,
|
|
||||||
lnwire.ErrSynchronizingChain,
|
|
||||||
)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// Ensure that the remote party respects our maximum channel size.
|
|
||||||
if amt > f.cfg.MaxChanSize {
|
|
||||||
f.failFundingFlow(
|
|
||||||
peer, msg.PendingChannelID,
|
|
||||||
lnwallet.ErrChanTooLarge(amt, f.cfg.MaxChanSize),
|
|
||||||
)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// We'll, also ensure that the remote party isn't attempting to propose
|
|
||||||
// a channel that's below our current min channel size.
|
|
||||||
if amt < f.cfg.MinChanSize {
|
|
||||||
f.failFundingFlow(
|
|
||||||
peer, msg.PendingChannelID,
|
|
||||||
lnwallet.ErrChanTooSmall(amt, btcutil.Amount(f.cfg.MinChanSize)),
|
|
||||||
)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// If request specifies non-zero push amount and 'rejectpush' is set,
|
|
||||||
// signal an error.
|
|
||||||
if f.cfg.RejectPush && msg.PushAmount > 0 {
|
|
||||||
f.failFundingFlow(
|
|
||||||
peer, msg.PendingChannelID,
|
|
||||||
lnwallet.ErrNonZeroPushAmount(),
|
|
||||||
)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// Send the OpenChannel request to the ChannelAcceptor to determine whether
|
|
||||||
// this node will accept the channel.
|
|
||||||
chanReq := &chanacceptor.ChannelAcceptRequest{
|
|
||||||
Node: peer.IdentityKey(),
|
|
||||||
OpenChanMsg: msg,
|
|
||||||
}
|
|
||||||
|
|
||||||
// Query our channel acceptor to determine whether we should reject
|
|
||||||
// the channel.
|
|
||||||
acceptorResp := f.cfg.OpenChannelPredicate.Accept(chanReq)
|
|
||||||
if acceptorResp.RejectChannel() {
|
|
||||||
f.failFundingFlow(
|
|
||||||
peer, msg.PendingChannelID,
|
|
||||||
acceptorResp.ChanAcceptError,
|
|
||||||
)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
fndgLog.Infof("Recv'd fundingRequest(amt=%v, push=%v, delay=%v, "+
|
|
||||||
"pendingId=%x) from peer(%x)", amt, msg.PushAmount,
|
|
||||||
msg.CsvDelay, msg.PendingChannelID,
|
|
||||||
peer.IdentityKey().SerializeCompressed())
|
|
||||||
|
|
||||||
// Attempt to initialize a reservation within the wallet. If the wallet
|
|
||||||
// has insufficient resources to create the channel, then the
|
|
||||||
// reservation attempt may be rejected. Note that since we're on the
|
|
||||||
// responding side of a single funder workflow, we don't commit any
|
|
||||||
// funds to the channel ourselves.
|
|
||||||
//
|
|
||||||
// Before we init the channel, we'll also check to see what commitment
|
|
||||||
// format we can use with this peer. This is dependent on *both* us and
|
|
||||||
// the remote peer are signaling the proper feature bit.
|
|
||||||
commitType := commitmentType(
|
|
||||||
peer.LocalFeatures(), peer.RemoteFeatures(),
|
|
||||||
)
|
|
||||||
chainHash := chainhash.Hash(msg.ChainHash)
|
|
||||||
req := &lnwallet.InitFundingReserveMsg{
|
|
||||||
ChainHash: &chainHash,
|
|
||||||
PendingChanID: msg.PendingChannelID,
|
|
||||||
NodeID: peer.IdentityKey(),
|
|
||||||
NodeAddr: peer.Address(),
|
|
||||||
LocalFundingAmt: 0,
|
|
||||||
RemoteFundingAmt: amt,
|
|
||||||
CommitFeePerKw: chainfee.SatPerKWeight(msg.FeePerKiloWeight),
|
|
||||||
FundingFeePerKw: 0,
|
|
||||||
PushMSat: msg.PushAmount,
|
|
||||||
Flags: msg.ChannelFlags,
|
|
||||||
MinConfs: 1,
|
|
||||||
CommitType: commitType,
|
|
||||||
}
|
|
||||||
|
|
||||||
reservation, err := f.cfg.Wallet.InitChannelReservation(req)
|
|
||||||
if err != nil {
|
|
||||||
fndgLog.Errorf("Unable to initialize reservation: %v", err)
|
|
||||||
f.failFundingFlow(peer, msg.PendingChannelID, err)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// As we're the responder, we get to specify the number of confirmations
|
|
||||||
// that we require before both of us consider the channel open. We'll
|
|
||||||
// use our mapping to derive the proper number of confirmations based on
|
|
||||||
// the amount of the channel, and also if any funds are being pushed to
|
|
||||||
// us. If a depth value was set by our channel acceptor, we will use
|
|
||||||
// that value instead.
|
|
||||||
numConfsReq := f.cfg.NumRequiredConfs(msg.FundingAmount, msg.PushAmount)
|
|
||||||
if acceptorResp.MinAcceptDepth != 0 {
|
|
||||||
numConfsReq = acceptorResp.MinAcceptDepth
|
|
||||||
}
|
|
||||||
reservation.SetNumConfsRequired(numConfsReq)
|
|
||||||
|
|
||||||
// We'll also validate and apply all the constraints the initiating
|
|
||||||
// party is attempting to dictate for our commitment transaction.
|
|
||||||
channelConstraints := &channeldb.ChannelConstraints{
|
|
||||||
DustLimit: msg.DustLimit,
|
|
||||||
ChanReserve: msg.ChannelReserve,
|
|
||||||
MaxPendingAmount: msg.MaxValueInFlight,
|
|
||||||
MinHTLC: msg.HtlcMinimum,
|
|
||||||
MaxAcceptedHtlcs: msg.MaxAcceptedHTLCs,
|
|
||||||
CsvDelay: msg.CsvDelay,
|
|
||||||
}
|
|
||||||
err = reservation.CommitConstraints(
|
|
||||||
channelConstraints, f.cfg.MaxLocalCSVDelay,
|
|
||||||
)
|
|
||||||
if err != nil {
|
|
||||||
fndgLog.Errorf("Unacceptable channel constraints: %v", err)
|
|
||||||
f.failFundingFlow(peer, msg.PendingChannelID, err)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check whether the peer supports upfront shutdown, and get a new wallet
|
|
||||||
// address if our node is configured to set shutdown addresses by default.
|
|
||||||
// We use the upfront shutdown script provided by our channel acceptor
|
|
||||||
// (if any) in lieu of user input.
|
|
||||||
shutdown, err := getUpfrontShutdownScript(
|
|
||||||
f.cfg.EnableUpfrontShutdown, peer, acceptorResp.UpfrontShutdown,
|
|
||||||
func() (lnwire.DeliveryAddress, error) {
|
|
||||||
addr, err := f.cfg.Wallet.NewAddress(lnwallet.WitnessPubKey, false)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
return txscript.PayToAddrScript(addr)
|
|
||||||
},
|
|
||||||
)
|
|
||||||
if err != nil {
|
|
||||||
f.failFundingFlow(
|
|
||||||
peer, msg.PendingChannelID,
|
|
||||||
fmt.Errorf("getUpfrontShutdownScript error: %v", err),
|
|
||||||
)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
reservation.SetOurUpfrontShutdown(shutdown)
|
|
||||||
|
|
||||||
fndgLog.Infof("Requiring %v confirmations for pendingChan(%x): "+
|
|
||||||
"amt=%v, push_amt=%v, committype=%v, upfrontShutdown=%x", numConfsReq,
|
|
||||||
msg.PendingChannelID, amt, msg.PushAmount,
|
|
||||||
commitType, msg.UpfrontShutdownScript)
|
|
||||||
|
|
||||||
// Generate our required constraints for the remote party, using the
|
|
||||||
// values provided by the channel acceptor if they are non-zero.
|
|
||||||
remoteCsvDelay := f.cfg.RequiredRemoteDelay(amt)
|
|
||||||
if acceptorResp.CSVDelay != 0 {
|
|
||||||
remoteCsvDelay = acceptorResp.CSVDelay
|
|
||||||
}
|
|
||||||
|
|
||||||
chanReserve := f.cfg.RequiredRemoteChanReserve(amt, msg.DustLimit)
|
|
||||||
if acceptorResp.Reserve != 0 {
|
|
||||||
chanReserve = acceptorResp.Reserve
|
|
||||||
}
|
|
||||||
|
|
||||||
remoteMaxValue := f.cfg.RequiredRemoteMaxValue(amt)
|
|
||||||
if acceptorResp.InFlightTotal != 0 {
|
|
||||||
remoteMaxValue = acceptorResp.InFlightTotal
|
|
||||||
}
|
|
||||||
|
|
||||||
maxHtlcs := f.cfg.RequiredRemoteMaxHTLCs(amt)
|
|
||||||
if acceptorResp.HtlcLimit != 0 {
|
|
||||||
maxHtlcs = acceptorResp.HtlcLimit
|
|
||||||
}
|
|
||||||
|
|
||||||
// Default to our default minimum hltc value, replacing it with the
|
|
||||||
// channel acceptor's value if it is set.
|
|
||||||
minHtlc := f.cfg.DefaultMinHtlcIn
|
|
||||||
if acceptorResp.MinHtlcIn != 0 {
|
|
||||||
minHtlc = acceptorResp.MinHtlcIn
|
|
||||||
}
|
|
||||||
|
|
||||||
// Once the reservation has been created successfully, we add it to
|
|
||||||
// this peer's map of pending reservations to track this particular
|
|
||||||
// reservation until either abort or completion.
|
|
||||||
f.resMtx.Lock()
|
|
||||||
if _, ok := f.activeReservations[peerIDKey]; !ok {
|
|
||||||
f.activeReservations[peerIDKey] = make(pendingChannels)
|
|
||||||
}
|
|
||||||
resCtx := &reservationWithCtx{
|
|
||||||
reservation: reservation,
|
|
||||||
chanAmt: amt,
|
|
||||||
remoteCsvDelay: remoteCsvDelay,
|
|
||||||
remoteMinHtlc: minHtlc,
|
|
||||||
remoteMaxValue: remoteMaxValue,
|
|
||||||
remoteMaxHtlcs: maxHtlcs,
|
|
||||||
maxLocalCsv: f.cfg.MaxLocalCSVDelay,
|
|
||||||
err: make(chan error, 1),
|
|
||||||
peer: peer,
|
|
||||||
}
|
|
||||||
f.activeReservations[peerIDKey][msg.PendingChannelID] = resCtx
|
|
||||||
f.resMtx.Unlock()
|
|
||||||
|
|
||||||
// Update the timestamp once the fundingOpenMsg has been handled.
|
|
||||||
defer resCtx.updateTimestamp()
|
|
||||||
|
|
||||||
// With our parameters set, we'll now process their contribution so we
|
|
||||||
// can move the funding workflow ahead.
|
|
||||||
remoteContribution := &lnwallet.ChannelContribution{
|
|
||||||
FundingAmount: amt,
|
|
||||||
FirstCommitmentPoint: msg.FirstCommitmentPoint,
|
|
||||||
ChannelConfig: &channeldb.ChannelConfig{
|
|
||||||
ChannelConstraints: channeldb.ChannelConstraints{
|
|
||||||
DustLimit: msg.DustLimit,
|
|
||||||
MaxPendingAmount: remoteMaxValue,
|
|
||||||
ChanReserve: chanReserve,
|
|
||||||
MinHTLC: minHtlc,
|
|
||||||
MaxAcceptedHtlcs: maxHtlcs,
|
|
||||||
CsvDelay: remoteCsvDelay,
|
|
||||||
},
|
|
||||||
MultiSigKey: keychain.KeyDescriptor{
|
|
||||||
PubKey: copyPubKey(msg.FundingKey),
|
|
||||||
},
|
|
||||||
RevocationBasePoint: keychain.KeyDescriptor{
|
|
||||||
PubKey: copyPubKey(msg.RevocationPoint),
|
|
||||||
},
|
|
||||||
PaymentBasePoint: keychain.KeyDescriptor{
|
|
||||||
PubKey: copyPubKey(msg.PaymentPoint),
|
|
||||||
},
|
|
||||||
DelayBasePoint: keychain.KeyDescriptor{
|
|
||||||
PubKey: copyPubKey(msg.DelayedPaymentPoint),
|
|
||||||
},
|
|
||||||
HtlcBasePoint: keychain.KeyDescriptor{
|
|
||||||
PubKey: copyPubKey(msg.HtlcPoint),
|
|
||||||
},
|
|
||||||
},
|
|
||||||
UpfrontShutdown: msg.UpfrontShutdownScript,
|
|
||||||
}
|
|
||||||
err = reservation.ProcessSingleContribution(remoteContribution)
|
|
||||||
if err != nil {
|
|
||||||
fndgLog.Errorf("unable to add contribution reservation: %v", err)
|
|
||||||
f.failFundingFlow(peer, msg.PendingChannelID, err)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
fndgLog.Infof("Sending fundingResp for pending_id(%x)",
|
|
||||||
msg.PendingChannelID)
|
|
||||||
fndgLog.Debugf("Remote party accepted commitment constraints: %v",
|
|
||||||
spew.Sdump(remoteContribution.ChannelConfig.ChannelConstraints))
|
|
||||||
|
|
||||||
// With the initiator's contribution recorded, respond with our
|
|
||||||
// contribution in the next message of the workflow.
|
|
||||||
ourContribution := reservation.OurContribution()
|
|
||||||
fundingAccept := lnwire.AcceptChannel{
|
|
||||||
PendingChannelID: msg.PendingChannelID,
|
|
||||||
DustLimit: ourContribution.DustLimit,
|
|
||||||
MaxValueInFlight: remoteMaxValue,
|
|
||||||
ChannelReserve: chanReserve,
|
|
||||||
MinAcceptDepth: uint32(numConfsReq),
|
|
||||||
HtlcMinimum: minHtlc,
|
|
||||||
CsvDelay: remoteCsvDelay,
|
|
||||||
MaxAcceptedHTLCs: maxHtlcs,
|
|
||||||
FundingKey: ourContribution.MultiSigKey.PubKey,
|
|
||||||
RevocationPoint: ourContribution.RevocationBasePoint.PubKey,
|
|
||||||
PaymentPoint: ourContribution.PaymentBasePoint.PubKey,
|
|
||||||
DelayedPaymentPoint: ourContribution.DelayBasePoint.PubKey,
|
|
||||||
HtlcPoint: ourContribution.HtlcBasePoint.PubKey,
|
|
||||||
FirstCommitmentPoint: ourContribution.FirstCommitmentPoint,
|
|
||||||
UpfrontShutdownScript: ourContribution.UpfrontShutdown,
|
|
||||||
}
|
|
||||||
|
|
||||||
if err := peer.SendMessage(true, &fundingAccept); err != nil {
|
|
||||||
fndgLog.Errorf("unable to send funding response to peer: %v", err)
|
|
||||||
f.failFundingFlow(peer, msg.PendingChannelID, err)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// handleFundingAccept processes a response to the workflow initiation sent by
|
|
||||||
// the remote peer. This message then queues a message with the funding
|
|
||||||
// outpoint, and a commitment signature to the remote peer.
|
|
||||||
func (f *Manager) handleFundingAccept(peer lnpeer.Peer,
|
|
||||||
msg *lnwire.AcceptChannel) {
|
|
||||||
|
|
||||||
pendingChanID := msg.PendingChannelID
|
|
||||||
peerKey := peer.IdentityKey()
|
|
||||||
|
|
||||||
resCtx, err := f.getReservationCtx(peerKey, pendingChanID)
|
|
||||||
if err != nil {
|
|
||||||
fndgLog.Warnf("Can't find reservation (peerKey:%v, chan_id:%v)",
|
|
||||||
peerKey, pendingChanID)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// Update the timestamp once the fundingAcceptMsg has been handled.
|
|
||||||
defer resCtx.updateTimestamp()
|
|
||||||
|
|
||||||
fndgLog.Infof("Recv'd fundingResponse for pending_id(%x)",
|
|
||||||
pendingChanID[:])
|
|
||||||
|
|
||||||
// The required number of confirmations should not be greater than the
|
|
||||||
// maximum number of confirmations required by the ChainNotifier to
|
|
||||||
// properly dispatch confirmations.
|
|
||||||
if msg.MinAcceptDepth > chainntnfs.MaxNumConfs {
|
|
||||||
err := lnwallet.ErrNumConfsTooLarge(
|
|
||||||
msg.MinAcceptDepth, chainntnfs.MaxNumConfs,
|
|
||||||
)
|
|
||||||
fndgLog.Warnf("Unacceptable channel constraints: %v", err)
|
|
||||||
f.failFundingFlow(peer, msg.PendingChannelID, err)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// We'll also specify the responder's preference for the number of
|
|
||||||
// required confirmations, and also the set of channel constraints
|
|
||||||
// they've specified for commitment states we can create.
|
|
||||||
resCtx.reservation.SetNumConfsRequired(uint16(msg.MinAcceptDepth))
|
|
||||||
channelConstraints := &channeldb.ChannelConstraints{
|
|
||||||
DustLimit: msg.DustLimit,
|
|
||||||
ChanReserve: msg.ChannelReserve,
|
|
||||||
MaxPendingAmount: msg.MaxValueInFlight,
|
|
||||||
MinHTLC: msg.HtlcMinimum,
|
|
||||||
MaxAcceptedHtlcs: msg.MaxAcceptedHTLCs,
|
|
||||||
CsvDelay: msg.CsvDelay,
|
|
||||||
}
|
|
||||||
err = resCtx.reservation.CommitConstraints(
|
|
||||||
channelConstraints, resCtx.maxLocalCsv,
|
|
||||||
)
|
|
||||||
if err != nil {
|
|
||||||
fndgLog.Warnf("Unacceptable channel constraints: %v", err)
|
|
||||||
f.failFundingFlow(peer, msg.PendingChannelID, err)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// As they've accepted our channel constraints, we'll regenerate them
|
|
||||||
// here so we can properly commit their accepted constraints to the
|
|
||||||
// reservation.
|
|
||||||
chanReserve := f.cfg.RequiredRemoteChanReserve(resCtx.chanAmt, msg.DustLimit)
|
|
||||||
|
|
||||||
// The remote node has responded with their portion of the channel
|
|
||||||
// contribution. At this point, we can process their contribution which
|
|
||||||
// allows us to construct and sign both the commitment transaction, and
|
|
||||||
// the funding transaction.
|
|
||||||
remoteContribution := &lnwallet.ChannelContribution{
|
|
||||||
FirstCommitmentPoint: msg.FirstCommitmentPoint,
|
|
||||||
ChannelConfig: &channeldb.ChannelConfig{
|
|
||||||
ChannelConstraints: channeldb.ChannelConstraints{
|
|
||||||
DustLimit: msg.DustLimit,
|
|
||||||
MaxPendingAmount: resCtx.remoteMaxValue,
|
|
||||||
ChanReserve: chanReserve,
|
|
||||||
MinHTLC: resCtx.remoteMinHtlc,
|
|
||||||
MaxAcceptedHtlcs: resCtx.remoteMaxHtlcs,
|
|
||||||
CsvDelay: resCtx.remoteCsvDelay,
|
|
||||||
},
|
|
||||||
MultiSigKey: keychain.KeyDescriptor{
|
|
||||||
PubKey: copyPubKey(msg.FundingKey),
|
|
||||||
},
|
|
||||||
RevocationBasePoint: keychain.KeyDescriptor{
|
|
||||||
PubKey: copyPubKey(msg.RevocationPoint),
|
|
||||||
},
|
|
||||||
PaymentBasePoint: keychain.KeyDescriptor{
|
|
||||||
PubKey: copyPubKey(msg.PaymentPoint),
|
|
||||||
},
|
|
||||||
DelayBasePoint: keychain.KeyDescriptor{
|
|
||||||
PubKey: copyPubKey(msg.DelayedPaymentPoint),
|
|
||||||
},
|
|
||||||
HtlcBasePoint: keychain.KeyDescriptor{
|
|
||||||
PubKey: copyPubKey(msg.HtlcPoint),
|
|
||||||
},
|
|
||||||
},
|
|
||||||
UpfrontShutdown: msg.UpfrontShutdownScript,
|
|
||||||
}
|
|
||||||
err = resCtx.reservation.ProcessContribution(remoteContribution)
|
|
||||||
|
|
||||||
// The wallet has detected that a PSBT funding process was requested by
|
|
||||||
// the user and has halted the funding process after negotiating the
|
|
||||||
// multisig keys. We now have everything that is needed for the user to
|
|
||||||
// start constructing a PSBT that sends to the multisig funding address.
|
|
||||||
var psbtIntent *chanfunding.PsbtIntent
|
|
||||||
if psbtErr, ok := err.(*lnwallet.PsbtFundingRequired); ok {
|
|
||||||
// Return the information that is needed by the user to
|
|
||||||
// construct the PSBT back to the caller.
|
|
||||||
addr, amt, packet, err := psbtErr.Intent.FundingParams()
|
|
||||||
if err != nil {
|
|
||||||
fndgLog.Errorf("Unable to process PSBT funding params "+
|
|
||||||
"for contribution from %v: %v", peerKey, err)
|
|
||||||
f.failFundingFlow(peer, msg.PendingChannelID, err)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
var buf bytes.Buffer
|
|
||||||
err = packet.Serialize(&buf)
|
|
||||||
if err != nil {
|
|
||||||
fndgLog.Errorf("Unable to serialize PSBT for "+
|
|
||||||
"contribution from %v: %v", peerKey, err)
|
|
||||||
f.failFundingFlow(peer, msg.PendingChannelID, err)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
resCtx.updates <- &lnrpc.OpenStatusUpdate{
|
|
||||||
PendingChanId: pendingChanID[:],
|
|
||||||
Update: &lnrpc.OpenStatusUpdate_PsbtFund{
|
|
||||||
PsbtFund: &lnrpc.ReadyForPsbtFunding{
|
|
||||||
FundingAddress: addr.EncodeAddress(),
|
|
||||||
FundingAmount: amt,
|
|
||||||
Psbt: buf.Bytes(),
|
|
||||||
},
|
|
||||||
},
|
|
||||||
}
|
|
||||||
psbtIntent = psbtErr.Intent
|
|
||||||
} else if err != nil {
|
|
||||||
fndgLog.Errorf("Unable to process contribution from %v: %v",
|
|
||||||
peerKey, err)
|
|
||||||
f.failFundingFlow(peer, msg.PendingChannelID, err)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
fndgLog.Infof("pendingChan(%x): remote party proposes num_confs=%v, "+
|
|
||||||
"csv_delay=%v", pendingChanID[:], msg.MinAcceptDepth, msg.CsvDelay)
|
|
||||||
fndgLog.Debugf("Remote party accepted commitment constraints: %v",
|
|
||||||
spew.Sdump(remoteContribution.ChannelConfig.ChannelConstraints))
|
|
||||||
|
|
||||||
// If the user requested funding through a PSBT, we cannot directly
|
|
||||||
// continue now and need to wait for the fully funded and signed PSBT
|
|
||||||
// to arrive. To not block any other channels from opening, we wait in
|
|
||||||
// a separate goroutine.
|
|
||||||
if psbtIntent != nil {
|
|
||||||
f.wg.Add(1)
|
|
||||||
go func() {
|
|
||||||
defer f.wg.Done()
|
|
||||||
f.waitForPsbt(psbtIntent, resCtx, pendingChanID)
|
|
||||||
}()
|
|
||||||
|
|
||||||
// With the new goroutine spawned, we can now exit to unblock
|
|
||||||
// the main event loop.
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// In a normal, non-PSBT funding flow, we can jump directly to the next
|
|
||||||
// step where we expect our contribution to be finalized.
|
|
||||||
f.continueFundingAccept(resCtx, pendingChanID)
|
|
||||||
}
|
|
||||||
|
|
||||||
// waitForPsbt blocks until either a signed PSBT arrives, an error occurs or
|
|
||||||
// the funding manager shuts down. In the case of a valid PSBT, the funding flow
|
|
||||||
// is continued.
|
|
||||||
//
|
|
||||||
// NOTE: This method must be called as a goroutine.
|
|
||||||
func (f *Manager) waitForPsbt(intent *chanfunding.PsbtIntent,
|
|
||||||
resCtx *reservationWithCtx, pendingChanID [32]byte) {
|
|
||||||
|
|
||||||
// failFlow is a helper that logs an error message with the current
|
|
||||||
// context and then fails the funding flow.
|
|
||||||
peerKey := resCtx.peer.IdentityKey()
|
|
||||||
failFlow := func(errMsg string, cause error) {
|
|
||||||
fndgLog.Errorf("Unable to handle funding accept message "+
|
|
||||||
"for peer_key=%x, pending_chan_id=%x: %s: %v",
|
|
||||||
peerKey.SerializeCompressed(), pendingChanID, errMsg,
|
|
||||||
cause)
|
|
||||||
f.failFundingFlow(resCtx.peer, pendingChanID, cause)
|
|
||||||
}
|
|
||||||
|
|
||||||
// We'll now wait until the intent has received the final and complete
|
|
||||||
// funding transaction. If the channel is closed without any error being
|
|
||||||
// sent, we know everything's going as expected.
|
|
||||||
select {
|
|
||||||
case err := <-intent.PsbtReady:
|
|
||||||
switch err {
|
|
||||||
// If the user canceled the funding reservation, we need to
|
|
||||||
// inform the other peer about us canceling the reservation.
|
|
||||||
case chanfunding.ErrUserCanceled:
|
|
||||||
failFlow("aborting PSBT flow", err)
|
|
||||||
return
|
|
||||||
|
|
||||||
// If the remote canceled the funding reservation, we don't need
|
|
||||||
// to send another fail message. But we want to inform the user
|
|
||||||
// about what happened.
|
|
||||||
case chanfunding.ErrRemoteCanceled:
|
|
||||||
fndgLog.Infof("Remote canceled, aborting PSBT flow "+
|
|
||||||
"for peer_key=%x, pending_chan_id=%x",
|
|
||||||
peerKey.SerializeCompressed(), pendingChanID)
|
|
||||||
return
|
|
||||||
|
|
||||||
// Nil error means the flow continues normally now.
|
|
||||||
case nil:
|
|
||||||
|
|
||||||
// For any other error, we'll fail the funding flow.
|
|
||||||
default:
|
|
||||||
failFlow("error waiting for PSBT flow", err)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// A non-nil error means we can continue the funding flow.
|
|
||||||
// Notify the wallet so it can prepare everything we need to
|
|
||||||
// continue.
|
|
||||||
err = resCtx.reservation.ProcessPsbt()
|
|
||||||
if err != nil {
|
|
||||||
failFlow("error continuing PSBT flow", err)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// We are now ready to continue the funding flow.
|
|
||||||
f.continueFundingAccept(resCtx, pendingChanID)
|
|
||||||
|
|
||||||
// Handle a server shutdown as well because the reservation won't
|
|
||||||
// survive a restart as it's in memory only.
|
|
||||||
case <-f.quit:
|
|
||||||
fndgLog.Errorf("Unable to handle funding accept message "+
|
|
||||||
"for peer_key=%x, pending_chan_id=%x: funding manager "+
|
|
||||||
"shutting down", peerKey.SerializeCompressed(),
|
|
||||||
pendingChanID)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// continueFundingAccept continues the channel funding flow once our
|
|
||||||
// contribution is finalized, the channel output is known and the funding
|
|
||||||
// transaction is signed.
|
|
||||||
func (f *Manager) continueFundingAccept(resCtx *reservationWithCtx,
|
|
||||||
pendingChanID [32]byte) {
|
|
||||||
|
|
||||||
// Now that we have their contribution, we can extract, then send over
|
|
||||||
// both the funding out point and our signature for their version of
|
|
||||||
// the commitment transaction to the remote peer.
|
|
||||||
outPoint := resCtx.reservation.FundingOutpoint()
|
|
||||||
_, sig := resCtx.reservation.OurSignatures()
|
|
||||||
|
|
||||||
// A new channel has almost finished the funding process. In order to
|
|
||||||
// properly synchronize with the writeHandler goroutine, we add a new
|
|
||||||
// channel to the barriers map which will be closed once the channel is
|
|
||||||
// fully open.
|
|
||||||
f.barrierMtx.Lock()
|
|
||||||
channelID := lnwire.NewChanIDFromOutPoint(outPoint)
|
|
||||||
fndgLog.Debugf("Creating chan barrier for ChanID(%v)", channelID)
|
|
||||||
f.newChanBarriers[channelID] = make(chan struct{})
|
|
||||||
f.barrierMtx.Unlock()
|
|
||||||
|
|
||||||
// The next message that advances the funding flow will reference the
|
|
||||||
// channel via its permanent channel ID, so we'll set up this mapping
|
|
||||||
// so we can retrieve the reservation context once we get the
|
|
||||||
// FundingSigned message.
|
|
||||||
f.resMtx.Lock()
|
|
||||||
f.signedReservations[channelID] = pendingChanID
|
|
||||||
f.resMtx.Unlock()
|
|
||||||
|
|
||||||
fndgLog.Infof("Generated ChannelPoint(%v) for pending_id(%x)", outPoint,
|
|
||||||
pendingChanID[:])
|
|
||||||
|
|
||||||
var err error
|
|
||||||
fundingCreated := &lnwire.FundingCreated{
|
|
||||||
PendingChannelID: pendingChanID,
|
|
||||||
FundingPoint: *outPoint,
|
|
||||||
}
|
|
||||||
fundingCreated.CommitSig, err = lnwire.NewSigFromSignature(sig)
|
|
||||||
if err != nil {
|
|
||||||
fndgLog.Errorf("Unable to parse signature: %v", err)
|
|
||||||
f.failFundingFlow(resCtx.peer, pendingChanID, err)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
if err := resCtx.peer.SendMessage(true, fundingCreated); err != nil {
|
|
||||||
fndgLog.Errorf("Unable to send funding complete message: %v", err)
|
|
||||||
f.failFundingFlow(resCtx.peer, pendingChanID, err)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// handleFundingCreated progresses the funding workflow when the daemon is on
|
|
||||||
// the responding side of a single funder workflow. Once this message has been
|
|
||||||
// processed, a signature is sent to the remote peer allowing it to broadcast
|
|
||||||
// the funding transaction, progressing the workflow into the final stage.
|
|
||||||
func (f *Manager) handleFundingCreated(peer lnpeer.Peer,
|
|
||||||
msg *lnwire.FundingCreated) {
|
|
||||||
|
|
||||||
peerKey := peer.IdentityKey()
|
|
||||||
pendingChanID := msg.PendingChannelID
|
|
||||||
|
|
||||||
resCtx, err := f.getReservationCtx(peerKey, pendingChanID)
|
|
||||||
if err != nil {
|
|
||||||
fndgLog.Warnf("can't find reservation (peer_id:%v, chan_id:%x)",
|
|
||||||
peerKey, pendingChanID[:])
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// The channel initiator has responded with the funding outpoint of the
|
|
||||||
// final funding transaction, as well as a signature for our version of
|
|
||||||
// the commitment transaction. So at this point, we can validate the
|
|
||||||
// initiator's commitment transaction, then send our own if it's valid.
|
|
||||||
// TODO(roasbeef): make case (p vs P) consistent throughout
|
|
||||||
fundingOut := msg.FundingPoint
|
|
||||||
fndgLog.Infof("completing pending_id(%x) with ChannelPoint(%v)",
|
|
||||||
pendingChanID[:], fundingOut)
|
|
||||||
|
|
||||||
commitSig, err := msg.CommitSig.ToSignature()
|
|
||||||
if err != nil {
|
|
||||||
fndgLog.Errorf("unable to parse signature: %v", err)
|
|
||||||
f.failFundingFlow(peer, pendingChanID, err)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// With all the necessary data available, attempt to advance the
|
|
||||||
// funding workflow to the next stage. If this succeeds then the
|
|
||||||
// funding transaction will broadcast after our next message.
|
|
||||||
// CompleteReservationSingle will also mark the channel as 'IsPending'
|
|
||||||
// in the database.
|
|
||||||
completeChan, err := resCtx.reservation.CompleteReservationSingle(
|
|
||||||
&fundingOut, commitSig,
|
|
||||||
)
|
|
||||||
if err != nil {
|
|
||||||
// TODO(roasbeef): better error logging: peerID, channelID, etc.
|
|
||||||
fndgLog.Errorf("unable to complete single reservation: %v", err)
|
|
||||||
f.failFundingFlow(peer, pendingChanID, err)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// The channel is marked IsPending in the database, and can be removed
|
|
||||||
// from the set of active reservations.
|
|
||||||
f.deleteReservationCtx(peerKey, msg.PendingChannelID)
|
|
||||||
|
|
||||||
// If something goes wrong before the funding transaction is confirmed,
|
|
||||||
// we use this convenience method to delete the pending OpenChannel
|
|
||||||
// from the database.
|
|
||||||
deleteFromDatabase := func() {
|
|
||||||
localBalance := completeChan.LocalCommitment.LocalBalance.ToSatoshis()
|
|
||||||
closeInfo := &channeldb.ChannelCloseSummary{
|
|
||||||
ChanPoint: completeChan.FundingOutpoint,
|
|
||||||
ChainHash: completeChan.ChainHash,
|
|
||||||
RemotePub: completeChan.IdentityPub,
|
|
||||||
CloseType: channeldb.FundingCanceled,
|
|
||||||
Capacity: completeChan.Capacity,
|
|
||||||
SettledBalance: localBalance,
|
|
||||||
RemoteCurrentRevocation: completeChan.RemoteCurrentRevocation,
|
|
||||||
RemoteNextRevocation: completeChan.RemoteNextRevocation,
|
|
||||||
LocalChanConfig: completeChan.LocalChanCfg,
|
|
||||||
}
|
|
||||||
|
|
||||||
// Close the channel with us as the initiator because we are
|
|
||||||
// deciding to exit the funding flow due to an internal error.
|
|
||||||
if err := completeChan.CloseChannel(
|
|
||||||
closeInfo, channeldb.ChanStatusLocalCloseInitiator,
|
|
||||||
); err != nil {
|
|
||||||
fndgLog.Errorf("Failed closing channel %v: %v",
|
|
||||||
completeChan.FundingOutpoint, err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// A new channel has almost finished the funding process. In order to
|
|
||||||
// properly synchronize with the writeHandler goroutine, we add a new
|
|
||||||
// channel to the barriers map which will be closed once the channel is
|
|
||||||
// fully open.
|
|
||||||
f.barrierMtx.Lock()
|
|
||||||
channelID := lnwire.NewChanIDFromOutPoint(&fundingOut)
|
|
||||||
fndgLog.Debugf("Creating chan barrier for ChanID(%v)", channelID)
|
|
||||||
f.newChanBarriers[channelID] = make(chan struct{})
|
|
||||||
f.barrierMtx.Unlock()
|
|
||||||
|
|
||||||
fndgLog.Infof("sending FundingSigned for pending_id(%x) over "+
|
|
||||||
"ChannelPoint(%v)", pendingChanID[:], fundingOut)
|
|
||||||
|
|
||||||
// With their signature for our version of the commitment transaction
|
|
||||||
// verified, we can now send over our signature to the remote peer.
|
|
||||||
_, sig := resCtx.reservation.OurSignatures()
|
|
||||||
ourCommitSig, err := lnwire.NewSigFromSignature(sig)
|
|
||||||
if err != nil {
|
|
||||||
fndgLog.Errorf("unable to parse signature: %v", err)
|
|
||||||
f.failFundingFlow(peer, pendingChanID, err)
|
|
||||||
deleteFromDatabase()
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
fundingSigned := &lnwire.FundingSigned{
|
|
||||||
ChanID: channelID,
|
|
||||||
CommitSig: ourCommitSig,
|
|
||||||
}
|
|
||||||
if err := peer.SendMessage(true, fundingSigned); err != nil {
|
|
||||||
fndgLog.Errorf("unable to send FundingSigned message: %v", err)
|
|
||||||
f.failFundingFlow(peer, pendingChanID, err)
|
|
||||||
deleteFromDatabase()
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// Now that we've sent over our final signature for this channel, we'll
|
|
||||||
// send it to the ChainArbitrator so it can watch for any on-chain
|
|
||||||
// actions during this final confirmation stage.
|
|
||||||
if err := f.cfg.WatchNewChannel(completeChan, peerKey); err != nil {
|
|
||||||
fndgLog.Errorf("Unable to send new ChannelPoint(%v) for "+
|
|
||||||
"arbitration: %v", fundingOut, err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Create an entry in the local discovery map so we can ensure that we
|
|
||||||
// process the channel confirmation fully before we receive a funding
|
|
||||||
// locked message.
|
|
||||||
f.localDiscoveryMtx.Lock()
|
|
||||||
f.localDiscoverySignals[channelID] = make(chan struct{})
|
|
||||||
f.localDiscoveryMtx.Unlock()
|
|
||||||
|
|
||||||
// Inform the ChannelNotifier that the channel has entered
|
|
||||||
// pending open state.
|
|
||||||
f.cfg.NotifyPendingOpenChannelEvent(fundingOut, completeChan)
|
|
||||||
|
|
||||||
// At this point we have sent our last funding message to the
|
|
||||||
// initiating peer before the funding transaction will be broadcast.
|
|
||||||
// With this last message, our job as the responder is now complete.
|
|
||||||
// We'll wait for the funding transaction to reach the specified number
|
|
||||||
// of confirmations, then start normal operations.
|
|
||||||
//
|
|
||||||
// When we get to this point we have sent the signComplete message to
|
|
||||||
// the channel funder, and BOLT#2 specifies that we MUST remember the
|
|
||||||
// channel for reconnection. The channel is already marked
|
|
||||||
// as pending in the database, so in case of a disconnect or restart,
|
|
||||||
// we will continue waiting for the confirmation the next time we start
|
|
||||||
// the funding manager. In case the funding transaction never appears
|
|
||||||
// on the blockchain, we must forget this channel. We therefore
|
|
||||||
// completely forget about this channel if we haven't seen the funding
|
|
||||||
// transaction in 288 blocks (~ 48 hrs), by canceling the reservation
|
|
||||||
// and canceling the wait for the funding confirmation.
|
|
||||||
f.wg.Add(1)
|
|
||||||
go f.advanceFundingState(completeChan, pendingChanID, nil)
|
|
||||||
}
|
|
||||||
|
|
||||||
// handleFundingSigned processes the final message received in a single funder
|
|
||||||
// workflow. Once this message is processed, the funding transaction is
|
|
||||||
// broadcast. Once the funding transaction reaches a sufficient number of
|
|
||||||
// confirmations, a message is sent to the responding peer along with a compact
|
|
||||||
// encoding of the location of the channel within the blockchain.
|
|
||||||
func (f *Manager) handleFundingSigned(peer lnpeer.Peer,
|
|
||||||
msg *lnwire.FundingSigned) {
|
|
||||||
|
|
||||||
// As the funding signed message will reference the reservation by its
|
|
||||||
// permanent channel ID, we'll need to perform an intermediate look up
|
|
||||||
// before we can obtain the reservation.
|
|
||||||
f.resMtx.Lock()
|
|
||||||
pendingChanID, ok := f.signedReservations[msg.ChanID]
|
|
||||||
delete(f.signedReservations, msg.ChanID)
|
|
||||||
f.resMtx.Unlock()
|
|
||||||
if !ok {
|
|
||||||
err := fmt.Errorf("unable to find signed reservation for "+
|
|
||||||
"chan_id=%x", msg.ChanID)
|
|
||||||
fndgLog.Warnf(err.Error())
|
|
||||||
f.failFundingFlow(peer, msg.ChanID, err)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
peerKey := peer.IdentityKey()
|
|
||||||
resCtx, err := f.getReservationCtx(peerKey, pendingChanID)
|
|
||||||
if err != nil {
|
|
||||||
fndgLog.Warnf("Unable to find reservation (peer_id:%v, "+
|
|
||||||
"chan_id:%x)", peerKey, pendingChanID[:])
|
|
||||||
// TODO: add ErrChanNotFound?
|
|
||||||
f.failFundingFlow(peer, pendingChanID, err)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// Create an entry in the local discovery map so we can ensure that we
|
|
||||||
// process the channel confirmation fully before we receive a funding
|
|
||||||
// locked message.
|
|
||||||
fundingPoint := resCtx.reservation.FundingOutpoint()
|
|
||||||
permChanID := lnwire.NewChanIDFromOutPoint(fundingPoint)
|
|
||||||
f.localDiscoveryMtx.Lock()
|
|
||||||
f.localDiscoverySignals[permChanID] = make(chan struct{})
|
|
||||||
f.localDiscoveryMtx.Unlock()
|
|
||||||
|
|
||||||
// The remote peer has responded with a signature for our commitment
|
|
||||||
// transaction. We'll verify the signature for validity, then commit
|
|
||||||
// the state to disk as we can now open the channel.
|
|
||||||
commitSig, err := msg.CommitSig.ToSignature()
|
|
||||||
if err != nil {
|
|
||||||
fndgLog.Errorf("Unable to parse signature: %v", err)
|
|
||||||
f.failFundingFlow(peer, pendingChanID, err)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
completeChan, err := resCtx.reservation.CompleteReservation(
|
|
||||||
nil, commitSig,
|
|
||||||
)
|
|
||||||
if err != nil {
|
|
||||||
fndgLog.Errorf("Unable to complete reservation sign "+
|
|
||||||
"complete: %v", err)
|
|
||||||
f.failFundingFlow(peer, pendingChanID, err)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// The channel is now marked IsPending in the database, and we can
|
|
||||||
// delete it from our set of active reservations.
|
|
||||||
f.deleteReservationCtx(peerKey, pendingChanID)
|
|
||||||
|
|
||||||
// Broadcast the finalized funding transaction to the network, but only
|
|
||||||
// if we actually have the funding transaction.
|
|
||||||
if completeChan.ChanType.HasFundingTx() {
|
|
||||||
fundingTx := completeChan.FundingTxn
|
|
||||||
var fundingTxBuf bytes.Buffer
|
|
||||||
if err := fundingTx.Serialize(&fundingTxBuf); err != nil {
|
|
||||||
fndgLog.Errorf("Unable to serialize funding "+
|
|
||||||
"transaction %v: %v", fundingTx.TxHash(), err)
|
|
||||||
|
|
||||||
// Clear the buffer of any bytes that were written
|
|
||||||
// before the serialization error to prevent logging an
|
|
||||||
// incomplete transaction.
|
|
||||||
fundingTxBuf.Reset()
|
|
||||||
}
|
|
||||||
|
|
||||||
fndgLog.Infof("Broadcasting funding tx for ChannelPoint(%v): %x",
|
|
||||||
completeChan.FundingOutpoint, fundingTxBuf.Bytes())
|
|
||||||
|
|
||||||
// Set a nil short channel ID at this stage because we do not
|
|
||||||
// know it until our funding tx confirms.
|
|
||||||
label := labels.MakeLabel(
|
|
||||||
labels.LabelTypeChannelOpen, nil,
|
|
||||||
)
|
|
||||||
|
|
||||||
err = f.cfg.PublishTransaction(fundingTx, label)
|
|
||||||
if err != nil {
|
|
||||||
fndgLog.Errorf("Unable to broadcast funding tx %x for "+
|
|
||||||
"ChannelPoint(%v): %v", fundingTxBuf.Bytes(),
|
|
||||||
completeChan.FundingOutpoint, err)
|
|
||||||
|
|
||||||
// We failed to broadcast the funding transaction, but
|
|
||||||
// watch the channel regardless, in case the
|
|
||||||
// transaction made it to the network. We will retry
|
|
||||||
// broadcast at startup.
|
|
||||||
//
|
|
||||||
// TODO(halseth): retry more often? Handle with CPFP?
|
|
||||||
// Just delete from the DB?
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Now that we have a finalized reservation for this funding flow,
|
|
||||||
// we'll send the to be active channel to the ChainArbitrator so it can
|
|
||||||
// watch for any on-chain actions before the channel has fully
|
|
||||||
// confirmed.
|
|
||||||
if err := f.cfg.WatchNewChannel(completeChan, peerKey); err != nil {
|
|
||||||
fndgLog.Errorf("Unable to send new ChannelPoint(%v) for "+
|
|
||||||
"arbitration: %v", fundingPoint, err)
|
|
||||||
}
|
|
||||||
|
|
||||||
fndgLog.Infof("Finalizing pending_id(%x) over ChannelPoint(%v), "+
|
|
||||||
"waiting for channel open on-chain", pendingChanID[:],
|
|
||||||
fundingPoint)
|
|
||||||
|
|
||||||
// Send an update to the upstream client that the negotiation process
|
|
||||||
// is over.
|
|
||||||
//
|
|
||||||
// TODO(roasbeef): add abstraction over updates to accommodate
|
|
||||||
// long-polling, or SSE, etc.
|
|
||||||
upd := &lnrpc.OpenStatusUpdate{
|
|
||||||
Update: &lnrpc.OpenStatusUpdate_ChanPending{
|
|
||||||
ChanPending: &lnrpc.PendingUpdate{
|
|
||||||
Txid: fundingPoint.Hash[:],
|
|
||||||
OutputIndex: fundingPoint.Index,
|
|
||||||
},
|
|
||||||
},
|
|
||||||
PendingChanId: pendingChanID[:],
|
|
||||||
}
|
|
||||||
|
|
||||||
select {
|
|
||||||
case resCtx.updates <- upd:
|
|
||||||
// Inform the ChannelNotifier that the channel has entered
|
|
||||||
// pending open state.
|
|
||||||
f.cfg.NotifyPendingOpenChannelEvent(*fundingPoint, completeChan)
|
|
||||||
case <-f.quit:
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// At this point we have broadcast the funding transaction and done all
|
|
||||||
// necessary processing.
|
|
||||||
f.wg.Add(1)
|
|
||||||
go f.advanceFundingState(completeChan, pendingChanID, resCtx.updates)
|
|
||||||
}
|
|
||||||
|
|
||||||
// confirmedChannel wraps a confirmed funding transaction, as well as the short
|
|
||||||
// channel ID which identifies that channel into a single struct. We'll use
|
|
||||||
// this to pass around the final state of a channel after it has been
|
|
||||||
// confirmed.
|
|
||||||
type confirmedChannel struct {
|
|
||||||
// shortChanID expresses where in the block the funding transaction was
|
|
||||||
// located.
|
|
||||||
shortChanID lnwire.ShortChannelID
|
|
||||||
|
|
||||||
// fundingTx is the funding transaction that created the channel.
|
|
||||||
fundingTx *wire.MsgTx
|
|
||||||
}
|
|
||||||
|
|
||||||
// waitForFundingWithTimeout is a wrapper around waitForFundingConfirmation and
|
|
||||||
// waitForTimeout that will return ErrConfirmationTimeout if we are not the
|
|
||||||
// channel initiator and the maxWaitNumBlocksFundingConf has passed from the
|
|
||||||
// funding broadcast height. In case of confirmation, the short channel ID of
|
|
||||||
// the channel and the funding transaction will be returned.
|
|
||||||
func (f *Manager) waitForFundingWithTimeout(
|
|
||||||
ch *channeldb.OpenChannel) (*confirmedChannel, error) {
|
|
||||||
|
|
||||||
confChan := make(chan *confirmedChannel)
|
|
||||||
timeoutChan := make(chan error, 1)
|
|
||||||
cancelChan := make(chan struct{})
|
|
||||||
|
|
||||||
f.wg.Add(1)
|
|
||||||
go f.waitForFundingConfirmation(ch, cancelChan, confChan)
|
|
||||||
|
|
||||||
// If we are not the initiator, we have no money at stake and will
|
|
||||||
// timeout waiting for the funding transaction to confirm after a
|
|
||||||
// while.
|
|
||||||
if !ch.IsInitiator {
|
|
||||||
f.wg.Add(1)
|
|
||||||
go f.waitForTimeout(ch, cancelChan, timeoutChan)
|
|
||||||
}
|
|
||||||
defer close(cancelChan)
|
|
||||||
|
|
||||||
select {
|
|
||||||
case err := <-timeoutChan:
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
return nil, ErrConfirmationTimeout
|
|
||||||
|
|
||||||
case <-f.quit:
|
|
||||||
// The fundingManager is shutting down, and will resume wait on
|
|
||||||
// startup.
|
|
||||||
return nil, ErrFundingManagerShuttingDown
|
|
||||||
|
|
||||||
case confirmedChannel, ok := <-confChan:
|
|
||||||
if !ok {
|
|
||||||
return nil, fmt.Errorf("waiting for funding" +
|
|
||||||
"confirmation failed")
|
|
||||||
}
|
|
||||||
return confirmedChannel, nil
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// makeFundingScript re-creates the funding script for the funding transaction
|
|
||||||
// of the target channel.
|
|
||||||
func makeFundingScript(channel *channeldb.OpenChannel) ([]byte, error) {
|
|
||||||
localKey := channel.LocalChanCfg.MultiSigKey.PubKey.SerializeCompressed()
|
|
||||||
remoteKey := channel.RemoteChanCfg.MultiSigKey.PubKey.SerializeCompressed()
|
|
||||||
|
|
||||||
multiSigScript, err := input.GenMultiSigScript(localKey, remoteKey)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
|
|
||||||
return input.WitnessScriptHash(multiSigScript)
|
|
||||||
}
|
|
||||||
|
|
||||||
// waitForFundingConfirmation handles the final stages of the channel funding
|
|
||||||
// process once the funding transaction has been broadcast. The primary
|
|
||||||
// function of waitForFundingConfirmation is to wait for blockchain
|
|
||||||
// confirmation, and then to notify the other systems that must be notified
|
|
||||||
// when a channel has become active for lightning transactions.
|
|
||||||
// The wait can be canceled by closing the cancelChan. In case of success,
|
|
||||||
// a *lnwire.ShortChannelID will be passed to confChan.
|
|
||||||
//
|
|
||||||
// NOTE: This MUST be run as a goroutine.
|
|
||||||
func (f *Manager) waitForFundingConfirmation(
|
|
||||||
completeChan *channeldb.OpenChannel, cancelChan <-chan struct{},
|
|
||||||
confChan chan<- *confirmedChannel) {
|
|
||||||
|
|
||||||
defer f.wg.Done()
|
|
||||||
defer close(confChan)
|
|
||||||
|
|
||||||
// Register with the ChainNotifier for a notification once the funding
|
|
||||||
// transaction reaches `numConfs` confirmations.
|
|
||||||
txid := completeChan.FundingOutpoint.Hash
|
|
||||||
fundingScript, err := makeFundingScript(completeChan)
|
|
||||||
if err != nil {
|
|
||||||
fndgLog.Errorf("unable to create funding script for "+
|
|
||||||
"ChannelPoint(%v): %v", completeChan.FundingOutpoint,
|
|
||||||
err)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
numConfs := uint32(completeChan.NumConfsRequired)
|
|
||||||
confNtfn, err := f.cfg.Notifier.RegisterConfirmationsNtfn(
|
|
||||||
&txid, fundingScript, numConfs,
|
|
||||||
completeChan.FundingBroadcastHeight,
|
|
||||||
)
|
|
||||||
if err != nil {
|
|
||||||
fndgLog.Errorf("Unable to register for confirmation of "+
|
|
||||||
"ChannelPoint(%v): %v", completeChan.FundingOutpoint,
|
|
||||||
err)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
fndgLog.Infof("Waiting for funding tx (%v) to reach %v confirmations",
|
|
||||||
txid, numConfs)
|
|
||||||
|
|
||||||
var confDetails *chainntnfs.TxConfirmation
|
|
||||||
var ok bool
|
|
||||||
|
|
||||||
// Wait until the specified number of confirmations has been reached,
|
|
||||||
// we get a cancel signal, or the wallet signals a shutdown.
|
|
||||||
select {
|
|
||||||
case confDetails, ok = <-confNtfn.Confirmed:
|
|
||||||
// fallthrough
|
|
||||||
|
|
||||||
case <-cancelChan:
|
|
||||||
fndgLog.Warnf("canceled waiting for funding confirmation, "+
|
|
||||||
"stopping funding flow for ChannelPoint(%v)",
|
|
||||||
completeChan.FundingOutpoint)
|
|
||||||
return
|
|
||||||
|
|
||||||
case <-f.quit:
|
|
||||||
fndgLog.Warnf("fundingManager shutting down, stopping funding "+
|
|
||||||
"flow for ChannelPoint(%v)",
|
|
||||||
completeChan.FundingOutpoint)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
if !ok {
|
|
||||||
fndgLog.Warnf("ChainNotifier shutting down, cannot complete "+
|
|
||||||
"funding flow for ChannelPoint(%v)",
|
|
||||||
completeChan.FundingOutpoint)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
fundingPoint := completeChan.FundingOutpoint
|
|
||||||
fndgLog.Infof("ChannelPoint(%v) is now active: ChannelID(%v)",
|
|
||||||
fundingPoint, lnwire.NewChanIDFromOutPoint(&fundingPoint))
|
|
||||||
|
|
||||||
// With the block height and the transaction index known, we can
|
|
||||||
// construct the compact chanID which is used on the network to unique
|
|
||||||
// identify channels.
|
|
||||||
shortChanID := lnwire.ShortChannelID{
|
|
||||||
BlockHeight: confDetails.BlockHeight,
|
|
||||||
TxIndex: confDetails.TxIndex,
|
|
||||||
TxPosition: uint16(fundingPoint.Index),
|
|
||||||
}
|
|
||||||
|
|
||||||
select {
|
|
||||||
case confChan <- &confirmedChannel{
|
|
||||||
shortChanID: shortChanID,
|
|
||||||
fundingTx: confDetails.Tx,
|
|
||||||
}:
|
|
||||||
case <-f.quit:
|
|
||||||
return
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// waitForTimeout will close the timeout channel if maxWaitNumBlocksFundingConf
|
|
||||||
// has passed from the broadcast height of the given channel. In case of error,
|
|
||||||
// the error is sent on timeoutChan. The wait can be canceled by closing the
|
|
||||||
// cancelChan.
|
|
||||||
//
|
|
||||||
// NOTE: timeoutChan MUST be buffered.
|
|
||||||
// NOTE: This MUST be run as a goroutine.
|
|
||||||
func (f *Manager) waitForTimeout(completeChan *channeldb.OpenChannel,
|
|
||||||
cancelChan <-chan struct{}, timeoutChan chan<- error) {
|
|
||||||
defer f.wg.Done()
|
|
||||||
|
|
||||||
epochClient, err := f.cfg.Notifier.RegisterBlockEpochNtfn(nil)
|
|
||||||
if err != nil {
|
|
||||||
timeoutChan <- fmt.Errorf("unable to register for epoch "+
|
|
||||||
"notification: %v", err)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
defer epochClient.Cancel()
|
|
||||||
|
|
||||||
// On block maxHeight we will cancel the funding confirmation wait.
|
|
||||||
maxHeight := completeChan.FundingBroadcastHeight + maxWaitNumBlocksFundingConf
|
|
||||||
for {
|
|
||||||
select {
|
|
||||||
case epoch, ok := <-epochClient.Epochs:
|
|
||||||
if !ok {
|
|
||||||
timeoutChan <- fmt.Errorf("epoch client " +
|
|
||||||
"shutting down")
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// Close the timeout channel and exit if the block is
|
|
||||||
// aboce the max height.
|
|
||||||
if uint32(epoch.Height) >= maxHeight {
|
|
||||||
fndgLog.Warnf("Waited for %v blocks without "+
|
|
||||||
"seeing funding transaction confirmed,"+
|
|
||||||
" cancelling.",
|
|
||||||
maxWaitNumBlocksFundingConf)
|
|
||||||
|
|
||||||
// Notify the caller of the timeout.
|
|
||||||
close(timeoutChan)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// TODO: If we are the channel initiator implement
|
|
||||||
// a method for recovering the funds from the funding
|
|
||||||
// transaction
|
|
||||||
|
|
||||||
case <-cancelChan:
|
|
||||||
return
|
|
||||||
|
|
||||||
case <-f.quit:
|
|
||||||
// The fundingManager is shutting down, will resume
|
|
||||||
// waiting for the funding transaction on startup.
|
|
||||||
return
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// handleFundingConfirmation marks a channel as open in the database, and set
|
|
||||||
// the channelOpeningState markedOpen. In addition it will report the now
|
|
||||||
// decided short channel ID to the switch, and close the local discovery signal
|
|
||||||
// for this channel.
|
|
||||||
func (f *Manager) handleFundingConfirmation(
|
|
||||||
completeChan *channeldb.OpenChannel,
|
|
||||||
confChannel *confirmedChannel) error {
|
|
||||||
|
|
||||||
fundingPoint := completeChan.FundingOutpoint
|
|
||||||
chanID := lnwire.NewChanIDFromOutPoint(&fundingPoint)
|
|
||||||
|
|
||||||
// TODO(roasbeef): ideally persistent state update for chan above
|
|
||||||
// should be abstracted
|
|
||||||
|
|
||||||
// Now that that the channel has been fully confirmed, we'll request
|
|
||||||
// that the wallet fully verify this channel to ensure that it can be
|
|
||||||
// used.
|
|
||||||
err := f.cfg.Wallet.ValidateChannel(completeChan, confChannel.fundingTx)
|
|
||||||
if err != nil {
|
|
||||||
// TODO(roasbeef): delete chan state?
|
|
||||||
return fmt.Errorf("unable to validate channel: %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// The funding transaction now being confirmed, we add this channel to
|
|
||||||
// the fundingManager's internal persistent state machine that we use
|
|
||||||
// to track the remaining process of the channel opening. This is
|
|
||||||
// useful to resume the opening process in case of restarts. We set the
|
|
||||||
// opening state before we mark the channel opened in the database,
|
|
||||||
// such that we can receover from one of the db writes failing.
|
|
||||||
err = f.saveChannelOpeningState(
|
|
||||||
&fundingPoint, markedOpen, &confChannel.shortChanID,
|
|
||||||
)
|
|
||||||
if err != nil {
|
|
||||||
return fmt.Errorf("error setting channel state to markedOpen: %v",
|
|
||||||
err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Now that the channel has been fully confirmed and we successfully
|
|
||||||
// saved the opening state, we'll mark it as open within the database.
|
|
||||||
err = completeChan.MarkAsOpen(confChannel.shortChanID)
|
|
||||||
if err != nil {
|
|
||||||
return fmt.Errorf("error setting channel pending flag to false: "+
|
|
||||||
"%v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Inform the ChannelNotifier that the channel has transitioned from
|
|
||||||
// pending open to open.
|
|
||||||
f.cfg.NotifyOpenChannelEvent(completeChan.FundingOutpoint)
|
|
||||||
|
|
||||||
// As there might already be an active link in the switch with an
|
|
||||||
// outdated short chan ID, we'll instruct the switch to load the updated
|
|
||||||
// short chan id from disk.
|
|
||||||
err = f.cfg.ReportShortChanID(fundingPoint)
|
|
||||||
if err != nil {
|
|
||||||
fndgLog.Errorf("unable to report short chan id: %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// If we opened the channel, and lnd's wallet published our funding tx
|
|
||||||
// (which is not the case for some channels) then we update our
|
|
||||||
// transaction label with our short channel ID, which is known now that
|
|
||||||
// our funding transaction has confirmed. We do not label transactions
|
|
||||||
// we did not publish, because our wallet has no knowledge of them.
|
|
||||||
if completeChan.IsInitiator && completeChan.ChanType.HasFundingTx() {
|
|
||||||
shortChanID := completeChan.ShortChanID()
|
|
||||||
label := labels.MakeLabel(
|
|
||||||
labels.LabelTypeChannelOpen, &shortChanID,
|
|
||||||
)
|
|
||||||
|
|
||||||
err = f.cfg.UpdateLabel(
|
|
||||||
completeChan.FundingOutpoint.Hash, label,
|
|
||||||
)
|
|
||||||
if err != nil {
|
|
||||||
fndgLog.Errorf("unable to update label: %v", err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Close the discoverySignal channel, indicating to a separate
|
|
||||||
// goroutine that the channel now is marked as open in the database
|
|
||||||
// and that it is acceptable to process funding locked messages
|
|
||||||
// from the peer.
|
|
||||||
f.localDiscoveryMtx.Lock()
|
|
||||||
if discoverySignal, ok := f.localDiscoverySignals[chanID]; ok {
|
|
||||||
close(discoverySignal)
|
|
||||||
}
|
|
||||||
f.localDiscoveryMtx.Unlock()
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// sendFundingLocked creates and sends the fundingLocked message.
|
|
||||||
// This should be called after the funding transaction has been confirmed,
|
|
||||||
// and the channelState is 'markedOpen'.
|
|
||||||
func (f *Manager) sendFundingLocked(
|
|
||||||
completeChan *channeldb.OpenChannel, channel *lnwallet.LightningChannel,
|
|
||||||
shortChanID *lnwire.ShortChannelID) error {
|
|
||||||
|
|
||||||
chanID := lnwire.NewChanIDFromOutPoint(&completeChan.FundingOutpoint)
|
|
||||||
|
|
||||||
var peerKey [33]byte
|
|
||||||
copy(peerKey[:], completeChan.IdentityPub.SerializeCompressed())
|
|
||||||
|
|
||||||
// Next, we'll send over the funding locked message which marks that we
|
|
||||||
// consider the channel open by presenting the remote party with our
|
|
||||||
// next revocation key. Without the revocation key, the remote party
|
|
||||||
// will be unable to propose state transitions.
|
|
||||||
nextRevocation, err := channel.NextRevocationKey()
|
|
||||||
if err != nil {
|
|
||||||
return fmt.Errorf("unable to create next revocation: %v", err)
|
|
||||||
}
|
|
||||||
fundingLockedMsg := lnwire.NewFundingLocked(chanID, nextRevocation)
|
|
||||||
|
|
||||||
// If the peer has disconnected before we reach this point, we will need
|
|
||||||
// to wait for him to come back online before sending the fundingLocked
|
|
||||||
// message. This is special for fundingLocked, since failing to send any
|
|
||||||
// of the previous messages in the funding flow just cancels the flow.
|
|
||||||
// But now the funding transaction is confirmed, the channel is open
|
|
||||||
// and we have to make sure the peer gets the fundingLocked message when
|
|
||||||
// it comes back online. This is also crucial during restart of lnd,
|
|
||||||
// where we might try to resend the fundingLocked message before the
|
|
||||||
// server has had the time to connect to the peer. We keep trying to
|
|
||||||
// send fundingLocked until we succeed, or the fundingManager is shut
|
|
||||||
// down.
|
|
||||||
for {
|
|
||||||
connected := make(chan lnpeer.Peer, 1)
|
|
||||||
f.cfg.NotifyWhenOnline(peerKey, connected)
|
|
||||||
|
|
||||||
var peer lnpeer.Peer
|
|
||||||
select {
|
|
||||||
case peer = <-connected:
|
|
||||||
case <-f.quit:
|
|
||||||
return ErrFundingManagerShuttingDown
|
|
||||||
}
|
|
||||||
|
|
||||||
fndgLog.Infof("Peer(%x) is online, sending FundingLocked "+
|
|
||||||
"for ChannelID(%v)", peerKey, chanID)
|
|
||||||
|
|
||||||
if err := peer.SendMessage(true, fundingLockedMsg); err == nil {
|
|
||||||
// Sending succeeded, we can break out and continue the
|
|
||||||
// funding flow.
|
|
||||||
break
|
|
||||||
}
|
|
||||||
|
|
||||||
fndgLog.Warnf("Unable to send fundingLocked to peer %x: %v. "+
|
|
||||||
"Will retry when online", peerKey, err)
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// addToRouterGraph sends a ChannelAnnouncement and a ChannelUpdate to the
|
|
||||||
// gossiper so that the channel is added to the Router's internal graph.
|
|
||||||
// These announcement messages are NOT broadcasted to the greater network,
|
|
||||||
// only to the channel counter party. The proofs required to announce the
|
|
||||||
// channel to the greater network will be created and sent in annAfterSixConfs.
|
|
||||||
func (f *Manager) addToRouterGraph(completeChan *channeldb.OpenChannel,
|
|
||||||
shortChanID *lnwire.ShortChannelID) error {
|
|
||||||
|
|
||||||
chanID := lnwire.NewChanIDFromOutPoint(&completeChan.FundingOutpoint)
|
|
||||||
|
|
||||||
// We'll obtain the min HTLC value we can forward in our direction, as
|
|
||||||
// we'll use this value within our ChannelUpdate. This constraint is
|
|
||||||
// originally set by the remote node, as it will be the one that will
|
|
||||||
// need to determine the smallest HTLC it deems economically relevant.
|
|
||||||
fwdMinHTLC := completeChan.LocalChanCfg.MinHTLC
|
|
||||||
|
|
||||||
// We don't necessarily want to go as low as the remote party
|
|
||||||
// allows. Check it against our default forwarding policy.
|
|
||||||
if fwdMinHTLC < f.cfg.DefaultRoutingPolicy.MinHTLCOut {
|
|
||||||
fwdMinHTLC = f.cfg.DefaultRoutingPolicy.MinHTLCOut
|
|
||||||
}
|
|
||||||
|
|
||||||
// We'll obtain the max HTLC value we can forward in our direction, as
|
|
||||||
// we'll use this value within our ChannelUpdate. This value must be <=
|
|
||||||
// channel capacity and <= the maximum in-flight msats set by the peer.
|
|
||||||
fwdMaxHTLC := completeChan.LocalChanCfg.MaxPendingAmount
|
|
||||||
capacityMSat := lnwire.NewMSatFromSatoshis(completeChan.Capacity)
|
|
||||||
if fwdMaxHTLC > capacityMSat {
|
|
||||||
fwdMaxHTLC = capacityMSat
|
|
||||||
}
|
|
||||||
|
|
||||||
ann, err := f.newChanAnnouncement(
|
|
||||||
f.cfg.IDKey, completeChan.IdentityPub,
|
|
||||||
completeChan.LocalChanCfg.MultiSigKey.PubKey,
|
|
||||||
completeChan.RemoteChanCfg.MultiSigKey.PubKey, *shortChanID,
|
|
||||||
chanID, fwdMinHTLC, fwdMaxHTLC,
|
|
||||||
)
|
|
||||||
if err != nil {
|
|
||||||
return fmt.Errorf("error generating channel "+
|
|
||||||
"announcement: %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Send ChannelAnnouncement and ChannelUpdate to the gossiper to add
|
|
||||||
// to the Router's topology.
|
|
||||||
errChan := f.cfg.SendAnnouncement(
|
|
||||||
ann.chanAnn, discovery.ChannelCapacity(completeChan.Capacity),
|
|
||||||
discovery.ChannelPoint(completeChan.FundingOutpoint),
|
|
||||||
)
|
|
||||||
select {
|
|
||||||
case err := <-errChan:
|
|
||||||
if err != nil {
|
|
||||||
if routing.IsError(err, routing.ErrOutdated,
|
|
||||||
routing.ErrIgnored) {
|
|
||||||
fndgLog.Debugf("Router rejected "+
|
|
||||||
"ChannelAnnouncement: %v", err)
|
|
||||||
} else {
|
|
||||||
return fmt.Errorf("error sending channel "+
|
|
||||||
"announcement: %v", err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
case <-f.quit:
|
|
||||||
return ErrFundingManagerShuttingDown
|
|
||||||
}
|
|
||||||
|
|
||||||
errChan = f.cfg.SendAnnouncement(ann.chanUpdateAnn)
|
|
||||||
select {
|
|
||||||
case err := <-errChan:
|
|
||||||
if err != nil {
|
|
||||||
if routing.IsError(err, routing.ErrOutdated,
|
|
||||||
routing.ErrIgnored) {
|
|
||||||
fndgLog.Debugf("Router rejected "+
|
|
||||||
"ChannelUpdate: %v", err)
|
|
||||||
} else {
|
|
||||||
return fmt.Errorf("error sending channel "+
|
|
||||||
"update: %v", err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
case <-f.quit:
|
|
||||||
return ErrFundingManagerShuttingDown
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// annAfterSixConfs broadcasts the necessary channel announcement messages to
|
|
||||||
// the network after 6 confs. Should be called after the fundingLocked message
|
|
||||||
// is sent and the channel is added to the router graph (channelState is
|
|
||||||
// 'addedToRouterGraph') and the channel is ready to be used. This is the last
|
|
||||||
// step in the channel opening process, and the opening state will be deleted
|
|
||||||
// from the database if successful.
|
|
||||||
func (f *Manager) annAfterSixConfs(completeChan *channeldb.OpenChannel,
|
|
||||||
shortChanID *lnwire.ShortChannelID) error {
|
|
||||||
|
|
||||||
// If this channel is not meant to be announced to the greater network,
|
|
||||||
// we'll only send our NodeAnnouncement to our counterparty to ensure we
|
|
||||||
// don't leak any of our information.
|
|
||||||
announceChan := completeChan.ChannelFlags&lnwire.FFAnnounceChannel != 0
|
|
||||||
if !announceChan {
|
|
||||||
fndgLog.Debugf("Will not announce private channel %v.",
|
|
||||||
shortChanID.ToUint64())
|
|
||||||
|
|
||||||
peerChan := make(chan lnpeer.Peer, 1)
|
|
||||||
|
|
||||||
var peerKey [33]byte
|
|
||||||
copy(peerKey[:], completeChan.IdentityPub.SerializeCompressed())
|
|
||||||
|
|
||||||
f.cfg.NotifyWhenOnline(peerKey, peerChan)
|
|
||||||
|
|
||||||
var peer lnpeer.Peer
|
|
||||||
select {
|
|
||||||
case peer = <-peerChan:
|
|
||||||
case <-f.quit:
|
|
||||||
return ErrFundingManagerShuttingDown
|
|
||||||
}
|
|
||||||
|
|
||||||
nodeAnn, err := f.cfg.CurrentNodeAnnouncement()
|
|
||||||
if err != nil {
|
|
||||||
return fmt.Errorf("unable to retrieve current node "+
|
|
||||||
"announcement: %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
chanID := lnwire.NewChanIDFromOutPoint(
|
|
||||||
&completeChan.FundingOutpoint,
|
|
||||||
)
|
|
||||||
pubKey := peer.PubKey()
|
|
||||||
fndgLog.Debugf("Sending our NodeAnnouncement for "+
|
|
||||||
"ChannelID(%v) to %x", chanID, pubKey)
|
|
||||||
|
|
||||||
// TODO(halseth): make reliable. If the peer is not online this
|
|
||||||
// will fail, and the opening process will stop. Should instead
|
|
||||||
// block here, waiting for the peer to come online.
|
|
||||||
if err := peer.SendMessage(true, &nodeAnn); err != nil {
|
|
||||||
return fmt.Errorf("unable to send node announcement "+
|
|
||||||
"to peer %x: %v", pubKey, err)
|
|
||||||
}
|
|
||||||
} else {
|
|
||||||
// Otherwise, we'll wait until the funding transaction has
|
|
||||||
// reached 6 confirmations before announcing it.
|
|
||||||
numConfs := uint32(completeChan.NumConfsRequired)
|
|
||||||
if numConfs < 6 {
|
|
||||||
numConfs = 6
|
|
||||||
}
|
|
||||||
txid := completeChan.FundingOutpoint.Hash
|
|
||||||
fndgLog.Debugf("Will announce channel %v after ChannelPoint"+
|
|
||||||
"(%v) has gotten %d confirmations",
|
|
||||||
shortChanID.ToUint64(), completeChan.FundingOutpoint,
|
|
||||||
numConfs)
|
|
||||||
|
|
||||||
fundingScript, err := makeFundingScript(completeChan)
|
|
||||||
if err != nil {
|
|
||||||
return fmt.Errorf("unable to create funding script for "+
|
|
||||||
"ChannelPoint(%v): %v",
|
|
||||||
completeChan.FundingOutpoint, err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Register with the ChainNotifier for a notification once the
|
|
||||||
// funding transaction reaches at least 6 confirmations.
|
|
||||||
confNtfn, err := f.cfg.Notifier.RegisterConfirmationsNtfn(
|
|
||||||
&txid, fundingScript, numConfs,
|
|
||||||
completeChan.FundingBroadcastHeight,
|
|
||||||
)
|
|
||||||
if err != nil {
|
|
||||||
return fmt.Errorf("unable to register for "+
|
|
||||||
"confirmation of ChannelPoint(%v): %v",
|
|
||||||
completeChan.FundingOutpoint, err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Wait until 6 confirmations has been reached or the wallet
|
|
||||||
// signals a shutdown.
|
|
||||||
select {
|
|
||||||
case _, ok := <-confNtfn.Confirmed:
|
|
||||||
if !ok {
|
|
||||||
return fmt.Errorf("ChainNotifier shutting "+
|
|
||||||
"down, cannot complete funding flow "+
|
|
||||||
"for ChannelPoint(%v)",
|
|
||||||
completeChan.FundingOutpoint)
|
|
||||||
}
|
|
||||||
// Fallthrough.
|
|
||||||
|
|
||||||
case <-f.quit:
|
|
||||||
return fmt.Errorf("%v, stopping funding flow for "+
|
|
||||||
"ChannelPoint(%v)",
|
|
||||||
ErrFundingManagerShuttingDown,
|
|
||||||
completeChan.FundingOutpoint)
|
|
||||||
}
|
|
||||||
|
|
||||||
fundingPoint := completeChan.FundingOutpoint
|
|
||||||
chanID := lnwire.NewChanIDFromOutPoint(&fundingPoint)
|
|
||||||
|
|
||||||
fndgLog.Infof("Announcing ChannelPoint(%v), short_chan_id=%v",
|
|
||||||
&fundingPoint, shortChanID)
|
|
||||||
|
|
||||||
// Create and broadcast the proofs required to make this channel
|
|
||||||
// public and usable for other nodes for routing.
|
|
||||||
err = f.announceChannel(
|
|
||||||
f.cfg.IDKey, completeChan.IdentityPub,
|
|
||||||
completeChan.LocalChanCfg.MultiSigKey.PubKey,
|
|
||||||
completeChan.RemoteChanCfg.MultiSigKey.PubKey,
|
|
||||||
*shortChanID, chanID,
|
|
||||||
)
|
|
||||||
if err != nil {
|
|
||||||
return fmt.Errorf("channel announcement failed: %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
fndgLog.Debugf("Channel with ChannelPoint(%v), short_chan_id=%v "+
|
|
||||||
"announced", &fundingPoint, shortChanID)
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// handleFundingLocked finalizes the channel funding process and enables the
|
|
||||||
// channel to enter normal operating mode.
|
|
||||||
func (f *Manager) handleFundingLocked(peer lnpeer.Peer,
|
|
||||||
msg *lnwire.FundingLocked) {
|
|
||||||
|
|
||||||
defer f.wg.Done()
|
|
||||||
fndgLog.Debugf("Received FundingLocked for ChannelID(%v) from "+
|
|
||||||
"peer %x", msg.ChanID,
|
|
||||||
peer.IdentityKey().SerializeCompressed())
|
|
||||||
|
|
||||||
// If we are currently in the process of handling a funding locked
|
|
||||||
// message for this channel, ignore.
|
|
||||||
f.handleFundingLockedMtx.Lock()
|
|
||||||
_, ok := f.handleFundingLockedBarriers[msg.ChanID]
|
|
||||||
if ok {
|
|
||||||
fndgLog.Infof("Already handling fundingLocked for "+
|
|
||||||
"ChannelID(%v), ignoring.", msg.ChanID)
|
|
||||||
f.handleFundingLockedMtx.Unlock()
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// If not already handling fundingLocked for this channel, set up
|
|
||||||
// barrier, and move on.
|
|
||||||
f.handleFundingLockedBarriers[msg.ChanID] = struct{}{}
|
|
||||||
f.handleFundingLockedMtx.Unlock()
|
|
||||||
|
|
||||||
defer func() {
|
|
||||||
f.handleFundingLockedMtx.Lock()
|
|
||||||
delete(f.handleFundingLockedBarriers, msg.ChanID)
|
|
||||||
f.handleFundingLockedMtx.Unlock()
|
|
||||||
}()
|
|
||||||
|
|
||||||
f.localDiscoveryMtx.Lock()
|
|
||||||
localDiscoverySignal, ok := f.localDiscoverySignals[msg.ChanID]
|
|
||||||
f.localDiscoveryMtx.Unlock()
|
|
||||||
|
|
||||||
if ok {
|
|
||||||
// Before we proceed with processing the funding locked
|
|
||||||
// message, we'll wait for the local waitForFundingConfirmation
|
|
||||||
// goroutine to signal that it has the necessary state in
|
|
||||||
// place. Otherwise, we may be missing critical information
|
|
||||||
// required to handle forwarded HTLC's.
|
|
||||||
select {
|
|
||||||
case <-localDiscoverySignal:
|
|
||||||
// Fallthrough
|
|
||||||
case <-f.quit:
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// With the signal received, we can now safely delete the entry
|
|
||||||
// from the map.
|
|
||||||
f.localDiscoveryMtx.Lock()
|
|
||||||
delete(f.localDiscoverySignals, msg.ChanID)
|
|
||||||
f.localDiscoveryMtx.Unlock()
|
|
||||||
}
|
|
||||||
|
|
||||||
// First, we'll attempt to locate the channel whose funding workflow is
|
|
||||||
// being finalized by this message. We go to the database rather than
|
|
||||||
// our reservation map as we may have restarted, mid funding flow.
|
|
||||||
chanID := msg.ChanID
|
|
||||||
channel, err := f.cfg.FindChannel(chanID)
|
|
||||||
if err != nil {
|
|
||||||
fndgLog.Errorf("Unable to locate ChannelID(%v), cannot complete "+
|
|
||||||
"funding", chanID)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// If the RemoteNextRevocation is non-nil, it means that we have
|
|
||||||
// already processed fundingLocked for this channel, so ignore.
|
|
||||||
if channel.RemoteNextRevocation != nil {
|
|
||||||
fndgLog.Infof("Received duplicate fundingLocked for "+
|
|
||||||
"ChannelID(%v), ignoring.", chanID)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// The funding locked message contains the next commitment point we'll
|
|
||||||
// need to create the next commitment state for the remote party. So
|
|
||||||
// we'll insert that into the channel now before passing it along to
|
|
||||||
// other sub-systems.
|
|
||||||
err = channel.InsertNextRevocation(msg.NextPerCommitmentPoint)
|
|
||||||
if err != nil {
|
|
||||||
fndgLog.Errorf("unable to insert next commitment point: %v", err)
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// Launch a defer so we _ensure_ that the channel barrier is properly
|
|
||||||
// closed even if the target peer is no longer online at this point.
|
|
||||||
defer func() {
|
|
||||||
// Close the active channel barrier signaling the readHandler
|
|
||||||
// that commitment related modifications to this channel can
|
|
||||||
// now proceed.
|
|
||||||
f.barrierMtx.Lock()
|
|
||||||
chanBarrier, ok := f.newChanBarriers[chanID]
|
|
||||||
if ok {
|
|
||||||
fndgLog.Tracef("Closing chan barrier for ChanID(%v)",
|
|
||||||
chanID)
|
|
||||||
close(chanBarrier)
|
|
||||||
delete(f.newChanBarriers, chanID)
|
|
||||||
}
|
|
||||||
f.barrierMtx.Unlock()
|
|
||||||
}()
|
|
||||||
|
|
||||||
if err := peer.AddNewChannel(channel, f.quit); err != nil {
|
|
||||||
fndgLog.Errorf("Unable to add new channel %v with peer %x: %v",
|
|
||||||
channel.FundingOutpoint,
|
|
||||||
peer.IdentityKey().SerializeCompressed(), err,
|
|
||||||
)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// chanAnnouncement encapsulates the two authenticated announcements that we
|
|
||||||
// send out to the network after a new channel has been created locally.
|
|
||||||
type chanAnnouncement struct {
|
|
||||||
chanAnn *lnwire.ChannelAnnouncement
|
|
||||||
chanUpdateAnn *lnwire.ChannelUpdate
|
|
||||||
chanProof *lnwire.AnnounceSignatures
|
|
||||||
}
|
|
||||||
|
|
||||||
// newChanAnnouncement creates the authenticated channel announcement messages
|
|
||||||
// required to broadcast a newly created channel to the network. The
|
|
||||||
// announcement is two part: the first part authenticates the existence of the
|
|
||||||
// channel and contains four signatures binding the funding pub keys and
|
|
||||||
// identity pub keys of both parties to the channel, and the second segment is
|
|
||||||
// authenticated only by us and contains our directional routing policy for the
|
|
||||||
// channel.
|
|
||||||
func (f *Manager) newChanAnnouncement(localPubKey, remotePubKey,
|
|
||||||
localFundingKey, remoteFundingKey *btcec.PublicKey,
|
|
||||||
shortChanID lnwire.ShortChannelID, chanID lnwire.ChannelID,
|
|
||||||
fwdMinHTLC, fwdMaxHTLC lnwire.MilliSatoshi) (*chanAnnouncement, error) {
|
|
||||||
|
|
||||||
chainHash := *f.cfg.Wallet.Cfg.NetParams.GenesisHash
|
|
||||||
|
|
||||||
// The unconditional section of the announcement is the ShortChannelID
|
|
||||||
// itself which compactly encodes the location of the funding output
|
|
||||||
// within the blockchain.
|
|
||||||
chanAnn := &lnwire.ChannelAnnouncement{
|
|
||||||
ShortChannelID: shortChanID,
|
|
||||||
Features: lnwire.NewRawFeatureVector(),
|
|
||||||
ChainHash: chainHash,
|
|
||||||
}
|
|
||||||
|
|
||||||
// The chanFlags field indicates which directed edge of the channel is
|
|
||||||
// being updated within the ChannelUpdateAnnouncement announcement
|
|
||||||
// below. A value of zero means it's the edge of the "first" node and 1
|
|
||||||
// being the other node.
|
|
||||||
var chanFlags lnwire.ChanUpdateChanFlags
|
|
||||||
|
|
||||||
// The lexicographical ordering of the two identity public keys of the
|
|
||||||
// nodes indicates which of the nodes is "first". If our serialized
|
|
||||||
// identity key is lower than theirs then we're the "first" node and
|
|
||||||
// second otherwise.
|
|
||||||
selfBytes := localPubKey.SerializeCompressed()
|
|
||||||
remoteBytes := remotePubKey.SerializeCompressed()
|
|
||||||
if bytes.Compare(selfBytes, remoteBytes) == -1 {
|
|
||||||
copy(chanAnn.NodeID1[:], localPubKey.SerializeCompressed())
|
|
||||||
copy(chanAnn.NodeID2[:], remotePubKey.SerializeCompressed())
|
|
||||||
copy(chanAnn.BitcoinKey1[:], localFundingKey.SerializeCompressed())
|
|
||||||
copy(chanAnn.BitcoinKey2[:], remoteFundingKey.SerializeCompressed())
|
|
||||||
|
|
||||||
// If we're the first node then update the chanFlags to
|
|
||||||
// indicate the "direction" of the update.
|
|
||||||
chanFlags = 0
|
|
||||||
} else {
|
|
||||||
copy(chanAnn.NodeID1[:], remotePubKey.SerializeCompressed())
|
|
||||||
copy(chanAnn.NodeID2[:], localPubKey.SerializeCompressed())
|
|
||||||
copy(chanAnn.BitcoinKey1[:], remoteFundingKey.SerializeCompressed())
|
|
||||||
copy(chanAnn.BitcoinKey2[:], localFundingKey.SerializeCompressed())
|
|
||||||
|
|
||||||
// If we're the second node then update the chanFlags to
|
|
||||||
// indicate the "direction" of the update.
|
|
||||||
chanFlags = 1
|
|
||||||
}
|
|
||||||
|
|
||||||
// Our channel update message flags will signal that we support the
|
|
||||||
// max_htlc field.
|
|
||||||
msgFlags := lnwire.ChanUpdateOptionMaxHtlc
|
|
||||||
|
|
||||||
// We announce the channel with the default values. Some of
|
|
||||||
// these values can later be changed by crafting a new ChannelUpdate.
|
|
||||||
chanUpdateAnn := &lnwire.ChannelUpdate{
|
|
||||||
ShortChannelID: shortChanID,
|
|
||||||
ChainHash: chainHash,
|
|
||||||
Timestamp: uint32(time.Now().Unix()),
|
|
||||||
MessageFlags: msgFlags,
|
|
||||||
ChannelFlags: chanFlags,
|
|
||||||
TimeLockDelta: uint16(f.cfg.DefaultRoutingPolicy.TimeLockDelta),
|
|
||||||
|
|
||||||
// We use the HtlcMinimumMsat that the remote party required us
|
|
||||||
// to use, as our ChannelUpdate will be used to carry HTLCs
|
|
||||||
// towards them.
|
|
||||||
HtlcMinimumMsat: fwdMinHTLC,
|
|
||||||
HtlcMaximumMsat: fwdMaxHTLC,
|
|
||||||
|
|
||||||
BaseFee: uint32(f.cfg.DefaultRoutingPolicy.BaseFee),
|
|
||||||
FeeRate: uint32(f.cfg.DefaultRoutingPolicy.FeeRate),
|
|
||||||
}
|
|
||||||
|
|
||||||
// With the channel update announcement constructed, we'll generate a
|
|
||||||
// signature that signs a double-sha digest of the announcement.
|
|
||||||
// This'll serve to authenticate this announcement and any other future
|
|
||||||
// updates we may send.
|
|
||||||
chanUpdateMsg, err := chanUpdateAnn.DataToSign()
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
sig, err := f.cfg.SignMessage(f.cfg.IDKey, chanUpdateMsg)
|
|
||||||
if err != nil {
|
|
||||||
return nil, errors.Errorf("unable to generate channel "+
|
|
||||||
"update announcement signature: %v", err)
|
|
||||||
}
|
|
||||||
chanUpdateAnn.Signature, err = lnwire.NewSigFromSignature(sig)
|
|
||||||
if err != nil {
|
|
||||||
return nil, errors.Errorf("unable to generate channel "+
|
|
||||||
"update announcement signature: %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// The channel existence proofs itself is currently announced in
|
|
||||||
// distinct message. In order to properly authenticate this message, we
|
|
||||||
// need two signatures: one under the identity public key used which
|
|
||||||
// signs the message itself and another signature of the identity
|
|
||||||
// public key under the funding key itself.
|
|
||||||
//
|
|
||||||
// TODO(roasbeef): use SignAnnouncement here instead?
|
|
||||||
chanAnnMsg, err := chanAnn.DataToSign()
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
nodeSig, err := f.cfg.SignMessage(f.cfg.IDKey, chanAnnMsg)
|
|
||||||
if err != nil {
|
|
||||||
return nil, errors.Errorf("unable to generate node "+
|
|
||||||
"signature for channel announcement: %v", err)
|
|
||||||
}
|
|
||||||
bitcoinSig, err := f.cfg.SignMessage(localFundingKey, chanAnnMsg)
|
|
||||||
if err != nil {
|
|
||||||
return nil, errors.Errorf("unable to generate bitcoin "+
|
|
||||||
"signature for node public key: %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
// Finally, we'll generate the announcement proof which we'll use to
|
|
||||||
// provide the other side with the necessary signatures required to
|
|
||||||
// allow them to reconstruct the full channel announcement.
|
|
||||||
proof := &lnwire.AnnounceSignatures{
|
|
||||||
ChannelID: chanID,
|
|
||||||
ShortChannelID: shortChanID,
|
|
||||||
}
|
|
||||||
proof.NodeSignature, err = lnwire.NewSigFromSignature(nodeSig)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
proof.BitcoinSignature, err = lnwire.NewSigFromSignature(bitcoinSig)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
|
|
||||||
return &chanAnnouncement{
|
|
||||||
chanAnn: chanAnn,
|
|
||||||
chanUpdateAnn: chanUpdateAnn,
|
|
||||||
chanProof: proof,
|
|
||||||
}, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// announceChannel announces a newly created channel to the rest of the network
|
|
||||||
// by crafting the two authenticated announcements required for the peers on
|
|
||||||
// the network to recognize the legitimacy of the channel. The crafted
|
|
||||||
// announcements are then sent to the channel router to handle broadcasting to
|
|
||||||
// the network during its next trickle.
|
|
||||||
// This method is synchronous and will return when all the network requests
|
|
||||||
// finish, either successfully or with an error.
|
|
||||||
func (f *Manager) announceChannel(localIDKey, remoteIDKey, localFundingKey,
|
|
||||||
remoteFundingKey *btcec.PublicKey, shortChanID lnwire.ShortChannelID,
|
|
||||||
chanID lnwire.ChannelID) error {
|
|
||||||
|
|
||||||
// First, we'll create the batch of announcements to be sent upon
|
|
||||||
// initial channel creation. This includes the channel announcement
|
|
||||||
// itself, the channel update announcement, and our half of the channel
|
|
||||||
// proof needed to fully authenticate the channel.
|
|
||||||
//
|
|
||||||
// We can pass in zeroes for the min and max htlc policy, because we
|
|
||||||
// only use the channel announcement message from the returned struct.
|
|
||||||
ann, err := f.newChanAnnouncement(localIDKey, remoteIDKey,
|
|
||||||
localFundingKey, remoteFundingKey, shortChanID, chanID,
|
|
||||||
0, 0,
|
|
||||||
)
|
|
||||||
if err != nil {
|
|
||||||
fndgLog.Errorf("can't generate channel announcement: %v", err)
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
// We only send the channel proof announcement and the node announcement
|
|
||||||
// because addToRouterGraph previously sent the ChannelAnnouncement and
|
|
||||||
// the ChannelUpdate announcement messages. The channel proof and node
|
|
||||||
// announcements are broadcast to the greater network.
|
|
||||||
errChan := f.cfg.SendAnnouncement(ann.chanProof)
|
|
||||||
select {
|
|
||||||
case err := <-errChan:
|
|
||||||
if err != nil {
|
|
||||||
if routing.IsError(err, routing.ErrOutdated,
|
|
||||||
routing.ErrIgnored) {
|
|
||||||
fndgLog.Debugf("Router rejected "+
|
|
||||||
"AnnounceSignatures: %v", err)
|
|
||||||
} else {
|
|
||||||
fndgLog.Errorf("Unable to send channel "+
|
|
||||||
"proof: %v", err)
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
case <-f.quit:
|
|
||||||
return ErrFundingManagerShuttingDown
|
|
||||||
}
|
|
||||||
|
|
||||||
// Now that the channel is announced to the network, we will also
|
|
||||||
// obtain and send a node announcement. This is done since a node
|
|
||||||
// announcement is only accepted after a channel is known for that
|
|
||||||
// particular node, and this might be our first channel.
|
|
||||||
nodeAnn, err := f.cfg.CurrentNodeAnnouncement()
|
|
||||||
if err != nil {
|
|
||||||
fndgLog.Errorf("can't generate node announcement: %v", err)
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
errChan = f.cfg.SendAnnouncement(&nodeAnn)
|
|
||||||
select {
|
|
||||||
case err := <-errChan:
|
|
||||||
if err != nil {
|
|
||||||
if routing.IsError(err, routing.ErrOutdated,
|
|
||||||
routing.ErrIgnored) {
|
|
||||||
fndgLog.Debugf("Router rejected "+
|
|
||||||
"NodeAnnouncement: %v", err)
|
|
||||||
} else {
|
|
||||||
fndgLog.Errorf("Unable to send node "+
|
|
||||||
"announcement: %v", err)
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
case <-f.quit:
|
|
||||||
return ErrFundingManagerShuttingDown
|
|
||||||
}
|
|
||||||
|
|
||||||
return nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// InitFundingWorkflow sends a message to the funding manager instructing it
|
|
||||||
// to initiate a single funder workflow with the source peer.
|
|
||||||
// TODO(roasbeef): re-visit blocking nature..
|
|
||||||
func (f *Manager) InitFundingWorkflow(msg *InitFundingMsg) {
|
|
||||||
f.fundingRequests <- msg
|
|
||||||
}
|
|
||||||
|
|
||||||
// getUpfrontShutdownScript takes a user provided script and a getScript
|
|
||||||
// function which can be used to generate an upfront shutdown script. If our
|
|
||||||
// peer does not support the feature, this function will error if a non-zero
|
|
||||||
// script was provided by the user, and return an empty script otherwise. If
|
|
||||||
// our peer does support the feature, we will return the user provided script
|
|
||||||
// if non-zero, or a freshly generated script if our node is configured to set
|
|
||||||
// upfront shutdown scripts automatically.
|
|
||||||
func getUpfrontShutdownScript(enableUpfrontShutdown bool, peer lnpeer.Peer,
|
|
||||||
script lnwire.DeliveryAddress,
|
|
||||||
getScript func() (lnwire.DeliveryAddress, error)) (lnwire.DeliveryAddress,
|
|
||||||
error) {
|
|
||||||
|
|
||||||
// Check whether the remote peer supports upfront shutdown scripts.
|
|
||||||
remoteUpfrontShutdown := peer.RemoteFeatures().HasFeature(
|
|
||||||
lnwire.UpfrontShutdownScriptOptional,
|
|
||||||
)
|
|
||||||
|
|
||||||
// If the peer does not support upfront shutdown scripts, and one has been
|
|
||||||
// provided, return an error because the feature is not supported.
|
|
||||||
if !remoteUpfrontShutdown && len(script) != 0 {
|
|
||||||
return nil, errUpfrontShutdownScriptNotSupported
|
|
||||||
}
|
|
||||||
|
|
||||||
// If the peer does not support upfront shutdown, return an empty address.
|
|
||||||
if !remoteUpfrontShutdown {
|
|
||||||
return nil, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// If the user has provided an script and the peer supports the feature,
|
|
||||||
// return it. Note that user set scripts override the enable upfront
|
|
||||||
// shutdown flag.
|
|
||||||
if len(script) > 0 {
|
|
||||||
return script, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// If we do not have setting of upfront shutdown script enabled, return
|
|
||||||
// an empty script.
|
|
||||||
if !enableUpfrontShutdown {
|
|
||||||
return nil, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
return getScript()
|
|
||||||
}
|
|
||||||
|
|
||||||
// handleInitFundingMsg creates a channel reservation within the daemon's
|
|
||||||
// wallet, then sends a funding request to the remote peer kicking off the
|
|
||||||
// funding workflow.
|
|
||||||
func (f *Manager) handleInitFundingMsg(msg *InitFundingMsg) {
|
|
||||||
var (
|
|
||||||
peerKey = msg.Peer.IdentityKey()
|
|
||||||
localAmt = msg.LocalFundingAmt
|
|
||||||
minHtlcIn = msg.MinHtlcIn
|
|
||||||
remoteCsvDelay = msg.RemoteCsvDelay
|
|
||||||
maxValue = msg.MaxValueInFlight
|
|
||||||
maxHtlcs = msg.MaxHtlcs
|
|
||||||
maxCSV = msg.MaxLocalCsv
|
|
||||||
)
|
|
||||||
|
|
||||||
// If no maximum CSV delay was set for this channel, we use our default
|
|
||||||
// value.
|
|
||||||
if maxCSV == 0 {
|
|
||||||
maxCSV = f.cfg.MaxLocalCSVDelay
|
|
||||||
}
|
|
||||||
|
|
||||||
// We'll determine our dust limit depending on which chain is active.
|
|
||||||
var ourDustLimit btcutil.Amount
|
|
||||||
switch f.cfg.RegisteredChains.PrimaryChain() {
|
|
||||||
case chainreg.BitcoinChain:
|
|
||||||
ourDustLimit = lnwallet.DefaultDustLimit()
|
|
||||||
case chainreg.LitecoinChain:
|
|
||||||
ourDustLimit = chainreg.DefaultLitecoinDustLimit
|
|
||||||
}
|
|
||||||
fndgLog.Infof("Initiating fundingRequest(local_amt=%v "+
|
|
||||||
"(subtract_fees=%v), push_amt=%v, chain_hash=%v, peer=%x, "+
|
|
||||||
"dust_limit=%v, min_confs=%v)", localAmt, msg.SubtractFees,
|
|
||||||
msg.PushAmt, msg.ChainHash, peerKey.SerializeCompressed(),
|
|
||||||
ourDustLimit, msg.MinConfs)
|
|
||||||
|
|
||||||
// We set the channel flags to indicate whether we want this channel to
|
|
||||||
// be announced to the network.
|
|
||||||
var channelFlags lnwire.FundingFlag
|
|
||||||
if !msg.Private {
|
|
||||||
// This channel will be announced.
|
|
||||||
channelFlags = lnwire.FFAnnounceChannel
|
|
||||||
}
|
|
||||||
|
|
||||||
// If the caller specified their own channel ID, then we'll use that.
|
|
||||||
// Otherwise we'll generate a fresh one as normal. This will be used
|
|
||||||
// to track this reservation throughout its lifetime.
|
|
||||||
var chanID [32]byte
|
|
||||||
if msg.PendingChanID == zeroID {
|
|
||||||
chanID = f.nextPendingChanID()
|
|
||||||
} else {
|
|
||||||
// If the user specified their own pending channel ID, then
|
|
||||||
// we'll ensure it doesn't collide with any existing pending
|
|
||||||
// channel ID.
|
|
||||||
chanID = msg.PendingChanID
|
|
||||||
if _, err := f.getReservationCtx(peerKey, chanID); err == nil {
|
|
||||||
msg.Err <- fmt.Errorf("pendingChannelID(%x) "+
|
|
||||||
"already present", chanID[:])
|
|
||||||
return
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// Check whether the peer supports upfront shutdown, and get an address
|
|
||||||
// which should be used (either a user specified address or a new
|
|
||||||
// address from the wallet if our node is configured to set shutdown
|
|
||||||
// address by default).
|
|
||||||
shutdown, err := getUpfrontShutdownScript(
|
|
||||||
f.cfg.EnableUpfrontShutdown, msg.Peer,
|
|
||||||
msg.ShutdownScript,
|
|
||||||
func() (lnwire.DeliveryAddress, error) {
|
|
||||||
addr, err := f.cfg.Wallet.NewAddress(
|
|
||||||
lnwallet.WitnessPubKey, false,
|
|
||||||
)
|
|
||||||
if err != nil {
|
|
||||||
return nil, err
|
|
||||||
}
|
|
||||||
return txscript.PayToAddrScript(addr)
|
|
||||||
},
|
|
||||||
)
|
|
||||||
if err != nil {
|
|
||||||
msg.Err <- err
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// Initialize a funding reservation with the local wallet. If the
|
|
||||||
// wallet doesn't have enough funds to commit to this channel, then the
|
|
||||||
// request will fail, and be aborted.
|
|
||||||
//
|
|
||||||
// Before we init the channel, we'll also check to see what commitment
|
|
||||||
// format we can use with this peer. This is dependent on *both* us and
|
|
||||||
// the remote peer are signaling the proper feature bit.
|
|
||||||
commitType := commitmentType(
|
|
||||||
msg.Peer.LocalFeatures(), msg.Peer.RemoteFeatures(),
|
|
||||||
)
|
|
||||||
|
|
||||||
// First, we'll query the fee estimator for a fee that should get the
|
|
||||||
// commitment transaction confirmed by the next few blocks (conf target
|
|
||||||
// of 3). We target the near blocks here to ensure that we'll be able
|
|
||||||
// to execute a timely unilateral channel closure if needed.
|
|
||||||
commitFeePerKw, err := f.cfg.FeeEstimator.EstimateFeePerKW(3)
|
|
||||||
if err != nil {
|
|
||||||
msg.Err <- err
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// For anchor channels cap the initial commit fee rate at our defined
|
|
||||||
// maximum.
|
|
||||||
if commitType == lnwallet.CommitmentTypeAnchorsZeroFeeHtlcTx &&
|
|
||||||
commitFeePerKw > f.cfg.MaxAnchorsCommitFeeRate {
|
|
||||||
|
|
||||||
commitFeePerKw = f.cfg.MaxAnchorsCommitFeeRate
|
|
||||||
}
|
|
||||||
|
|
||||||
req := &lnwallet.InitFundingReserveMsg{
|
|
||||||
ChainHash: &msg.ChainHash,
|
|
||||||
PendingChanID: chanID,
|
|
||||||
NodeID: peerKey,
|
|
||||||
NodeAddr: msg.Peer.Address(),
|
|
||||||
SubtractFees: msg.SubtractFees,
|
|
||||||
LocalFundingAmt: localAmt,
|
|
||||||
RemoteFundingAmt: 0,
|
|
||||||
CommitFeePerKw: commitFeePerKw,
|
|
||||||
FundingFeePerKw: msg.FundingFeePerKw,
|
|
||||||
PushMSat: msg.PushAmt,
|
|
||||||
Flags: channelFlags,
|
|
||||||
MinConfs: msg.MinConfs,
|
|
||||||
CommitType: commitType,
|
|
||||||
ChanFunder: msg.ChanFunder,
|
|
||||||
}
|
|
||||||
|
|
||||||
reservation, err := f.cfg.Wallet.InitChannelReservation(req)
|
|
||||||
if err != nil {
|
|
||||||
msg.Err <- err
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// Set our upfront shutdown address in the existing reservation.
|
|
||||||
reservation.SetOurUpfrontShutdown(shutdown)
|
|
||||||
|
|
||||||
// Now that we have successfully reserved funds for this channel in the
|
|
||||||
// wallet, we can fetch the final channel capacity. This is done at
|
|
||||||
// this point since the final capacity might change in case of
|
|
||||||
// SubtractFees=true.
|
|
||||||
capacity := reservation.Capacity()
|
|
||||||
|
|
||||||
fndgLog.Infof("Target commit tx sat/kw for pendingID(%x): %v", chanID,
|
|
||||||
int64(commitFeePerKw))
|
|
||||||
|
|
||||||
// If the remote CSV delay was not set in the open channel request,
|
|
||||||
// we'll use the RequiredRemoteDelay closure to compute the delay we
|
|
||||||
// require given the total amount of funds within the channel.
|
|
||||||
if remoteCsvDelay == 0 {
|
|
||||||
remoteCsvDelay = f.cfg.RequiredRemoteDelay(capacity)
|
|
||||||
}
|
|
||||||
|
|
||||||
// If no minimum HTLC value was specified, use the default one.
|
|
||||||
if minHtlcIn == 0 {
|
|
||||||
minHtlcIn = f.cfg.DefaultMinHtlcIn
|
|
||||||
}
|
|
||||||
|
|
||||||
// If no max value was specified, use the default one.
|
|
||||||
if maxValue == 0 {
|
|
||||||
maxValue = f.cfg.RequiredRemoteMaxValue(capacity)
|
|
||||||
}
|
|
||||||
|
|
||||||
if maxHtlcs == 0 {
|
|
||||||
maxHtlcs = f.cfg.RequiredRemoteMaxHTLCs(capacity)
|
|
||||||
}
|
|
||||||
|
|
||||||
// If a pending channel map for this peer isn't already created, then
|
|
||||||
// we create one, ultimately allowing us to track this pending
|
|
||||||
// reservation within the target peer.
|
|
||||||
peerIDKey := newSerializedKey(peerKey)
|
|
||||||
f.resMtx.Lock()
|
|
||||||
if _, ok := f.activeReservations[peerIDKey]; !ok {
|
|
||||||
f.activeReservations[peerIDKey] = make(pendingChannels)
|
|
||||||
}
|
|
||||||
|
|
||||||
resCtx := &reservationWithCtx{
|
|
||||||
chanAmt: capacity,
|
|
||||||
remoteCsvDelay: remoteCsvDelay,
|
|
||||||
remoteMinHtlc: minHtlcIn,
|
|
||||||
remoteMaxValue: maxValue,
|
|
||||||
remoteMaxHtlcs: maxHtlcs,
|
|
||||||
maxLocalCsv: maxCSV,
|
|
||||||
reservation: reservation,
|
|
||||||
peer: msg.Peer,
|
|
||||||
updates: msg.Updates,
|
|
||||||
err: msg.Err,
|
|
||||||
}
|
|
||||||
f.activeReservations[peerIDKey][chanID] = resCtx
|
|
||||||
f.resMtx.Unlock()
|
|
||||||
|
|
||||||
// Update the timestamp once the InitFundingMsg has been handled.
|
|
||||||
defer resCtx.updateTimestamp()
|
|
||||||
|
|
||||||
// Once the reservation has been created, and indexed, queue a funding
|
|
||||||
// request to the remote peer, kicking off the funding workflow.
|
|
||||||
ourContribution := reservation.OurContribution()
|
|
||||||
|
|
||||||
// Finally, we'll use the current value of the channels and our default
|
|
||||||
// policy to determine of required commitment constraints for the
|
|
||||||
// remote party.
|
|
||||||
chanReserve := f.cfg.RequiredRemoteChanReserve(capacity, ourDustLimit)
|
|
||||||
|
|
||||||
fndgLog.Infof("Starting funding workflow with %v for pending_id(%x), "+
|
|
||||||
"committype=%v", msg.Peer.Address(), chanID, commitType)
|
|
||||||
|
|
||||||
fundingOpen := lnwire.OpenChannel{
|
|
||||||
ChainHash: *f.cfg.Wallet.Cfg.NetParams.GenesisHash,
|
|
||||||
PendingChannelID: chanID,
|
|
||||||
FundingAmount: capacity,
|
|
||||||
PushAmount: msg.PushAmt,
|
|
||||||
DustLimit: ourContribution.DustLimit,
|
|
||||||
MaxValueInFlight: maxValue,
|
|
||||||
ChannelReserve: chanReserve,
|
|
||||||
HtlcMinimum: minHtlcIn,
|
|
||||||
FeePerKiloWeight: uint32(commitFeePerKw),
|
|
||||||
CsvDelay: remoteCsvDelay,
|
|
||||||
MaxAcceptedHTLCs: maxHtlcs,
|
|
||||||
FundingKey: ourContribution.MultiSigKey.PubKey,
|
|
||||||
RevocationPoint: ourContribution.RevocationBasePoint.PubKey,
|
|
||||||
PaymentPoint: ourContribution.PaymentBasePoint.PubKey,
|
|
||||||
HtlcPoint: ourContribution.HtlcBasePoint.PubKey,
|
|
||||||
DelayedPaymentPoint: ourContribution.DelayBasePoint.PubKey,
|
|
||||||
FirstCommitmentPoint: ourContribution.FirstCommitmentPoint,
|
|
||||||
ChannelFlags: channelFlags,
|
|
||||||
UpfrontShutdownScript: shutdown,
|
|
||||||
}
|
|
||||||
if err := msg.Peer.SendMessage(true, &fundingOpen); err != nil {
|
|
||||||
e := fmt.Errorf("unable to send funding request message: %v",
|
|
||||||
err)
|
|
||||||
fndgLog.Errorf(e.Error())
|
|
||||||
|
|
||||||
// Since we were unable to send the initial message to the peer
|
|
||||||
// and start the funding flow, we'll cancel this reservation.
|
|
||||||
_, err := f.cancelReservationCtx(peerKey, chanID, false)
|
|
||||||
if err != nil {
|
|
||||||
fndgLog.Errorf("unable to cancel reservation: %v", err)
|
|
||||||
}
|
|
||||||
|
|
||||||
msg.Err <- e
|
|
||||||
return
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// handleErrorMsg processes the error which was received from remote peer,
|
|
||||||
// depending on the type of error we should do different clean up steps and
|
|
||||||
// inform the user about it.
|
|
||||||
func (f *Manager) handleErrorMsg(peer lnpeer.Peer,
|
|
||||||
msg *lnwire.Error) {
|
|
||||||
|
|
||||||
chanID := msg.ChanID
|
|
||||||
peerKey := peer.IdentityKey()
|
|
||||||
|
|
||||||
// First, we'll attempt to retrieve and cancel the funding workflow
|
|
||||||
// that this error was tied to. If we're unable to do so, then we'll
|
|
||||||
// exit early as this was an unwarranted error.
|
|
||||||
resCtx, err := f.cancelReservationCtx(peerKey, chanID, true)
|
|
||||||
if err != nil {
|
|
||||||
fndgLog.Warnf("Received error for non-existent funding "+
|
|
||||||
"flow: %v (%v)", err, msg.Error())
|
|
||||||
return
|
|
||||||
}
|
|
||||||
|
|
||||||
// If we did indeed find the funding workflow, then we'll return the
|
|
||||||
// error back to the caller (if any), and cancel the workflow itself.
|
|
||||||
fundingErr := fmt.Errorf("received funding error from %x: %v",
|
|
||||||
peerKey.SerializeCompressed(), msg.Error(),
|
|
||||||
)
|
|
||||||
fndgLog.Errorf(fundingErr.Error())
|
|
||||||
|
|
||||||
// If this was a PSBT funding flow, the remote likely timed out because
|
|
||||||
// we waited too long. Return a nice error message to the user in that
|
|
||||||
// case so the user knows what's the problem.
|
|
||||||
if resCtx.reservation.IsPsbt() {
|
|
||||||
fundingErr = fmt.Errorf("%w: %v", chanfunding.ErrRemoteCanceled,
|
|
||||||
fundingErr)
|
|
||||||
}
|
|
||||||
|
|
||||||
resCtx.err <- fundingErr
|
|
||||||
}
|
|
||||||
|
|
||||||
// pruneZombieReservations loops through all pending reservations and fails the
|
|
||||||
// funding flow for any reservations that have not been updated since the
|
|
||||||
// ReservationTimeout and are not locked waiting for the funding transaction.
|
|
||||||
func (f *Manager) pruneZombieReservations() {
|
|
||||||
zombieReservations := make(pendingChannels)
|
|
||||||
|
|
||||||
f.resMtx.RLock()
|
|
||||||
for _, pendingReservations := range f.activeReservations {
|
|
||||||
for pendingChanID, resCtx := range pendingReservations {
|
|
||||||
if resCtx.isLocked() {
|
|
||||||
continue
|
|
||||||
}
|
|
||||||
|
|
||||||
// We don't want to expire PSBT funding reservations.
|
|
||||||
// These reservations are always initiated by us and the
|
|
||||||
// remote peer is likely going to cancel them after some
|
|
||||||
// idle time anyway. So no need for us to also prune
|
|
||||||
// them.
|
|
||||||
sinceLastUpdate := time.Since(resCtx.lastUpdated)
|
|
||||||
isExpired := sinceLastUpdate > f.cfg.ReservationTimeout
|
|
||||||
if !resCtx.reservation.IsPsbt() && isExpired {
|
|
||||||
zombieReservations[pendingChanID] = resCtx
|
|
||||||
}
|
|
||||||
}
|
|
||||||
}
|
|
||||||
f.resMtx.RUnlock()
|
|
||||||
|
|
||||||
for pendingChanID, resCtx := range zombieReservations {
|
|
||||||
err := fmt.Errorf("reservation timed out waiting for peer "+
|
|
||||||
"(peer_id:%x, chan_id:%x)", resCtx.peer.IdentityKey(),
|
|
||||||
pendingChanID[:])
|
|
||||||
fndgLog.Warnf(err.Error())
|
|
||||||
f.failFundingFlow(resCtx.peer, pendingChanID, err)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// cancelReservationCtx does all needed work in order to securely cancel the
|
|
||||||
// reservation.
|
|
||||||
func (f *Manager) cancelReservationCtx(peerKey *btcec.PublicKey,
|
|
||||||
pendingChanID [32]byte, byRemote bool) (*reservationWithCtx, error) {
|
|
||||||
|
|
||||||
fndgLog.Infof("Cancelling funding reservation for node_key=%x, "+
|
|
||||||
"chan_id=%x", peerKey.SerializeCompressed(), pendingChanID[:])
|
|
||||||
|
|
||||||
peerIDKey := newSerializedKey(peerKey)
|
|
||||||
f.resMtx.Lock()
|
|
||||||
defer f.resMtx.Unlock()
|
|
||||||
|
|
||||||
nodeReservations, ok := f.activeReservations[peerIDKey]
|
|
||||||
if !ok {
|
|
||||||
// No reservations for this node.
|
|
||||||
return nil, errors.Errorf("no active reservations for peer(%x)",
|
|
||||||
peerIDKey[:])
|
|
||||||
}
|
|
||||||
|
|
||||||
ctx, ok := nodeReservations[pendingChanID]
|
|
||||||
if !ok {
|
|
||||||
return nil, errors.Errorf("unknown channel (id: %x) for "+
|
|
||||||
"peer(%x)", pendingChanID[:], peerIDKey[:])
|
|
||||||
}
|
|
||||||
|
|
||||||
// If the reservation was a PSBT funding flow and it was canceled by the
|
|
||||||
// remote peer, then we need to thread through a different error message
|
|
||||||
// to the subroutine that's waiting for the user input so it can return
|
|
||||||
// a nice error message to the user.
|
|
||||||
if ctx.reservation.IsPsbt() && byRemote {
|
|
||||||
ctx.reservation.RemoteCanceled()
|
|
||||||
}
|
|
||||||
|
|
||||||
if err := ctx.reservation.Cancel(); err != nil {
|
|
||||||
return nil, errors.Errorf("unable to cancel reservation: %v",
|
|
||||||
err)
|
|
||||||
}
|
|
||||||
|
|
||||||
delete(nodeReservations, pendingChanID)
|
|
||||||
|
|
||||||
// If this was the last active reservation for this peer, delete the
|
|
||||||
// peer's entry altogether.
|
|
||||||
if len(nodeReservations) == 0 {
|
|
||||||
delete(f.activeReservations, peerIDKey)
|
|
||||||
}
|
|
||||||
return ctx, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// deleteReservationCtx deletes the reservation uniquely identified by the
|
|
||||||
// target public key of the peer, and the specified pending channel ID.
|
|
||||||
func (f *Manager) deleteReservationCtx(peerKey *btcec.PublicKey,
|
|
||||||
pendingChanID [32]byte) {
|
|
||||||
|
|
||||||
// TODO(roasbeef): possibly cancel funding barrier in peer's
|
|
||||||
// channelManager?
|
|
||||||
peerIDKey := newSerializedKey(peerKey)
|
|
||||||
f.resMtx.Lock()
|
|
||||||
defer f.resMtx.Unlock()
|
|
||||||
|
|
||||||
nodeReservations, ok := f.activeReservations[peerIDKey]
|
|
||||||
if !ok {
|
|
||||||
// No reservations for this node.
|
|
||||||
return
|
|
||||||
}
|
|
||||||
delete(nodeReservations, pendingChanID)
|
|
||||||
|
|
||||||
// If this was the last active reservation for this peer, delete the
|
|
||||||
// peer's entry altogether.
|
|
||||||
if len(nodeReservations) == 0 {
|
|
||||||
delete(f.activeReservations, peerIDKey)
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// getReservationCtx returns the reservation context for a particular pending
|
|
||||||
// channel ID for a target peer.
|
|
||||||
func (f *Manager) getReservationCtx(peerKey *btcec.PublicKey,
|
|
||||||
pendingChanID [32]byte) (*reservationWithCtx, error) {
|
|
||||||
|
|
||||||
peerIDKey := newSerializedKey(peerKey)
|
|
||||||
f.resMtx.RLock()
|
|
||||||
resCtx, ok := f.activeReservations[peerIDKey][pendingChanID]
|
|
||||||
f.resMtx.RUnlock()
|
|
||||||
|
|
||||||
if !ok {
|
|
||||||
return nil, errors.Errorf("unknown channel (id: %x) for "+
|
|
||||||
"peer(%x)", pendingChanID[:], peerIDKey[:])
|
|
||||||
}
|
|
||||||
|
|
||||||
return resCtx, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// IsPendingChannel returns a boolean indicating whether the channel identified
|
|
||||||
// by the pendingChanID and given peer is pending, meaning it is in the process
|
|
||||||
// of being funded. After the funding transaction has been confirmed, the
|
|
||||||
// channel will receive a new, permanent channel ID, and will no longer be
|
|
||||||
// considered pending.
|
|
||||||
func (f *Manager) IsPendingChannel(pendingChanID [32]byte,
|
|
||||||
peer lnpeer.Peer) bool {
|
|
||||||
|
|
||||||
peerIDKey := newSerializedKey(peer.IdentityKey())
|
|
||||||
f.resMtx.RLock()
|
|
||||||
_, ok := f.activeReservations[peerIDKey][pendingChanID]
|
|
||||||
f.resMtx.RUnlock()
|
|
||||||
|
|
||||||
return ok
|
|
||||||
}
|
|
||||||
|
|
||||||
func copyPubKey(pub *btcec.PublicKey) *btcec.PublicKey {
|
|
||||||
return &btcec.PublicKey{
|
|
||||||
Curve: btcec.S256(),
|
|
||||||
X: pub.X,
|
|
||||||
Y: pub.Y,
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
// saveChannelOpeningState saves the channelOpeningState for the provided
|
|
||||||
// chanPoint to the channelOpeningStateBucket.
|
|
||||||
func (f *Manager) saveChannelOpeningState(chanPoint *wire.OutPoint,
|
|
||||||
state channelOpeningState, shortChanID *lnwire.ShortChannelID) error {
|
|
||||||
return kvdb.Update(f.cfg.Wallet.Cfg.Database, func(tx kvdb.RwTx) error {
|
|
||||||
|
|
||||||
bucket, err := tx.CreateTopLevelBucket(channelOpeningStateBucket)
|
|
||||||
if err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
var outpointBytes bytes.Buffer
|
|
||||||
if err = funding.WriteOutpoint(&outpointBytes, chanPoint); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
// Save state and the uint64 representation of the shortChanID
|
|
||||||
// for later use.
|
|
||||||
scratch := make([]byte, 10)
|
|
||||||
byteOrder.PutUint16(scratch[:2], uint16(state))
|
|
||||||
byteOrder.PutUint64(scratch[2:], shortChanID.ToUint64())
|
|
||||||
|
|
||||||
return bucket.Put(outpointBytes.Bytes(), scratch)
|
|
||||||
}, func() {})
|
|
||||||
}
|
|
||||||
|
|
||||||
// getChannelOpeningState fetches the channelOpeningState for the provided
|
|
||||||
// chanPoint from the database, or returns ErrChannelNotFound if the channel
|
|
||||||
// is not found.
|
|
||||||
func (f *Manager) getChannelOpeningState(chanPoint *wire.OutPoint) (
|
|
||||||
channelOpeningState, *lnwire.ShortChannelID, error) {
|
|
||||||
|
|
||||||
var state channelOpeningState
|
|
||||||
var shortChanID lnwire.ShortChannelID
|
|
||||||
err := kvdb.View(f.cfg.Wallet.Cfg.Database, func(tx kvdb.RTx) error {
|
|
||||||
|
|
||||||
bucket := tx.ReadBucket(channelOpeningStateBucket)
|
|
||||||
if bucket == nil {
|
|
||||||
// If the bucket does not exist, it means we never added
|
|
||||||
// a channel to the db, so return ErrChannelNotFound.
|
|
||||||
return ErrChannelNotFound
|
|
||||||
}
|
|
||||||
|
|
||||||
var outpointBytes bytes.Buffer
|
|
||||||
if err := funding.WriteOutpoint(&outpointBytes, chanPoint); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
value := bucket.Get(outpointBytes.Bytes())
|
|
||||||
if value == nil {
|
|
||||||
return ErrChannelNotFound
|
|
||||||
}
|
|
||||||
|
|
||||||
state = channelOpeningState(byteOrder.Uint16(value[:2]))
|
|
||||||
shortChanID = lnwire.NewShortChanIDFromInt(byteOrder.Uint64(value[2:]))
|
|
||||||
return nil
|
|
||||||
}, func() {})
|
|
||||||
if err != nil {
|
|
||||||
return 0, nil, err
|
|
||||||
}
|
|
||||||
|
|
||||||
return state, &shortChanID, nil
|
|
||||||
}
|
|
||||||
|
|
||||||
// deleteChannelOpeningState removes any state for chanPoint from the database.
|
|
||||||
func (f *Manager) deleteChannelOpeningState(chanPoint *wire.OutPoint) error {
|
|
||||||
return kvdb.Update(f.cfg.Wallet.Cfg.Database, func(tx kvdb.RwTx) error {
|
|
||||||
bucket := tx.ReadWriteBucket(channelOpeningStateBucket)
|
|
||||||
if bucket == nil {
|
|
||||||
return fmt.Errorf("bucket not found")
|
|
||||||
}
|
|
||||||
|
|
||||||
var outpointBytes bytes.Buffer
|
|
||||||
if err := funding.WriteOutpoint(&outpointBytes, chanPoint); err != nil {
|
|
||||||
return err
|
|
||||||
}
|
|
||||||
|
|
||||||
return bucket.Delete(outpointBytes.Bytes())
|
|
||||||
}, func() {})
|
|
||||||
}
|
|
1
log.go
1
log.go
@ -82,7 +82,6 @@ var (
|
|||||||
ltndLog = addLndPkgLogger("LTND")
|
ltndLog = addLndPkgLogger("LTND")
|
||||||
rpcsLog = addLndPkgLogger("RPCS")
|
rpcsLog = addLndPkgLogger("RPCS")
|
||||||
srvrLog = addLndPkgLogger("SRVR")
|
srvrLog = addLndPkgLogger("SRVR")
|
||||||
fndgLog = addLndPkgLogger("FNDG")
|
|
||||||
utxnLog = addLndPkgLogger("UTXN")
|
utxnLog = addLndPkgLogger("UTXN")
|
||||||
brarLog = addLndPkgLogger("BRAR")
|
brarLog = addLndPkgLogger("BRAR")
|
||||||
atplLog = addLndPkgLogger("ATPL")
|
atplLog = addLndPkgLogger("ATPL")
|
||||||
|
3
pilot.go
3
pilot.go
@ -10,6 +10,7 @@ import (
|
|||||||
"github.com/btcsuite/btcutil"
|
"github.com/btcsuite/btcutil"
|
||||||
"github.com/lightningnetwork/lnd/autopilot"
|
"github.com/lightningnetwork/lnd/autopilot"
|
||||||
"github.com/lightningnetwork/lnd/chainreg"
|
"github.com/lightningnetwork/lnd/chainreg"
|
||||||
|
"github.com/lightningnetwork/lnd/funding"
|
||||||
"github.com/lightningnetwork/lnd/lncfg"
|
"github.com/lightningnetwork/lnd/lncfg"
|
||||||
"github.com/lightningnetwork/lnd/lnwire"
|
"github.com/lightningnetwork/lnd/lnwire"
|
||||||
"github.com/lightningnetwork/lnd/tor"
|
"github.com/lightningnetwork/lnd/tor"
|
||||||
@ -97,7 +98,7 @@ func (c *chanController) OpenChannel(target *btcec.PublicKey,
|
|||||||
|
|
||||||
// Construct the open channel request and send it to the server to begin
|
// Construct the open channel request and send it to the server to begin
|
||||||
// the funding workflow.
|
// the funding workflow.
|
||||||
req := &InitFundingMsg{
|
req := &funding.InitFundingMsg{
|
||||||
TargetPubkey: target,
|
TargetPubkey: target,
|
||||||
ChainHash: *c.netParams.GenesisHash,
|
ChainHash: *c.netParams.GenesisHash,
|
||||||
SubtractFees: true,
|
SubtractFees: true,
|
||||||
|
@ -1765,7 +1765,7 @@ func (r *rpcServer) canOpenChannel() error {
|
|||||||
// struct. The logic is abstracted so that it can be shared between OpenChannel
|
// struct. The logic is abstracted so that it can be shared between OpenChannel
|
||||||
// and OpenChannelSync.
|
// and OpenChannelSync.
|
||||||
func (r *rpcServer) parseOpenChannelReq(in *lnrpc.OpenChannelRequest,
|
func (r *rpcServer) parseOpenChannelReq(in *lnrpc.OpenChannelRequest,
|
||||||
isSync bool) (*InitFundingMsg, error) {
|
isSync bool) (*funding.InitFundingMsg, error) {
|
||||||
|
|
||||||
rpcsLog.Debugf("[openchannel] request to NodeKey(%x) "+
|
rpcsLog.Debugf("[openchannel] request to NodeKey(%x) "+
|
||||||
"allocation(us=%v, them=%v)", in.NodePubkey,
|
"allocation(us=%v, them=%v)", in.NodePubkey,
|
||||||
@ -1892,7 +1892,7 @@ func (r *rpcServer) parseOpenChannelReq(in *lnrpc.OpenChannelRequest,
|
|||||||
// Instruct the server to trigger the necessary events to attempt to
|
// Instruct the server to trigger the necessary events to attempt to
|
||||||
// open a new channel. A stream is returned in place, this stream will
|
// open a new channel. A stream is returned in place, this stream will
|
||||||
// be used to consume updates of the state of the pending channel.
|
// be used to consume updates of the state of the pending channel.
|
||||||
return &InitFundingMsg{
|
return &funding.InitFundingMsg{
|
||||||
TargetPubkey: nodePubKey,
|
TargetPubkey: nodePubKey,
|
||||||
ChainHash: *r.cfg.ActiveNetParams.GenesisHash,
|
ChainHash: *r.cfg.ActiveNetParams.GenesisHash,
|
||||||
LocalFundingAmt: localFundingAmt,
|
LocalFundingAmt: localFundingAmt,
|
||||||
|
@ -218,7 +218,7 @@ type server struct {
|
|||||||
|
|
||||||
cc *chainreg.ChainControl
|
cc *chainreg.ChainControl
|
||||||
|
|
||||||
fundingMgr *Manager
|
fundingMgr *funding.Manager
|
||||||
|
|
||||||
localChanDB *channeldb.DB
|
localChanDB *channeldb.DB
|
||||||
|
|
||||||
@ -1001,7 +1001,7 @@ func newServer(cfg *Config, listenAddrs []net.Addr,
|
|||||||
return nil, err
|
return nil, err
|
||||||
}
|
}
|
||||||
|
|
||||||
s.fundingMgr, err = NewFundingManager(fundingConfig{
|
s.fundingMgr, err = funding.NewFundingManager(funding.Config{
|
||||||
NoWumboChans: !cfg.ProtocolOptions.Wumbo(),
|
NoWumboChans: !cfg.ProtocolOptions.Wumbo(),
|
||||||
IDKey: nodeKeyECDH.PubKey(),
|
IDKey: nodeKeyECDH.PubKey(),
|
||||||
Wallet: cc.Wallet,
|
Wallet: cc.Wallet,
|
||||||
@ -3627,7 +3627,7 @@ func (s *server) DisconnectPeer(pubKey *btcec.PublicKey) error {
|
|||||||
//
|
//
|
||||||
// NOTE: This function is safe for concurrent access.
|
// NOTE: This function is safe for concurrent access.
|
||||||
func (s *server) OpenChannel(
|
func (s *server) OpenChannel(
|
||||||
req *InitFundingMsg) (chan *lnrpc.OpenStatusUpdate, chan error) {
|
req *funding.InitFundingMsg) (chan *lnrpc.OpenStatusUpdate, chan error) {
|
||||||
|
|
||||||
// The updateChan will have a buffer of 2, since we expect a ChanPending
|
// The updateChan will have a buffer of 2, since we expect a ChanPending
|
||||||
// + a ChanOpen update, and we want to make sure the funding process is
|
// + a ChanOpen update, and we want to make sure the funding process is
|
||||||
|
Loading…
Reference in New Issue
Block a user