package main import ( "container/list" "fmt" "net" "strings" "sync" "sync/atomic" "time" "github.com/davecgh/go-spew/spew" "github.com/lightningnetwork/lnd/brontide" "bytes" "github.com/go-errors/errors" "github.com/lightningnetwork/lnd/chainntnfs" "github.com/lightningnetwork/lnd/channeldb" "github.com/lightningnetwork/lnd/htlcswitch" "github.com/lightningnetwork/lnd/lnrpc" "github.com/lightningnetwork/lnd/lnwallet" "github.com/lightningnetwork/lnd/lnwire" "github.com/lightningnetwork/lnd/routing" "github.com/roasbeef/btcd/btcec" "github.com/roasbeef/btcd/chaincfg/chainhash" "github.com/roasbeef/btcd/connmgr" "github.com/roasbeef/btcd/txscript" "github.com/roasbeef/btcd/wire" ) var ( numNodes int32 ) const ( // pingInterval is the interval at which ping messages are sent. pingInterval = 1 * time.Minute // idleTimeout is the duration of inactivity before we time out a peer. idleTimeout = 5 * time.Minute // outgoingQueueLen is the buffer size of the channel which houses // messages to be sent across the wire, requested by objects outside // this struct. outgoingQueueLen = 50 ) // outgoinMsg packages an lnwire.Message to be sent out on the wire, along with // a buffered channel which will be sent upon once the write is complete. This // buffered channel acts as a semaphore to be used for synchronization purposes. type outgoinMsg struct { msg lnwire.Message sentChan chan struct{} // MUST be buffered. } // newChannelMsg packages a lnwallet.LightningChannel with a channel that // allows the receiver of the request to report when the funding transaction // has been confirmed and the channel creation process completed. type newChannelMsg struct { channel *lnwallet.LightningChannel done chan struct{} } // chanSnapshotReq is a message sent by outside subsystems to a peer in order // to gain a snapshot of the peer's currently active channels. type chanSnapshotReq struct { resp chan []*channeldb.ChannelSnapshot } // peer is an active peer on the Lightning Network. This struct is responsible // for managing any channel state related to this peer. To do so, it has // several helper goroutines to handle events such as HTLC timeouts, new // funding workflow, and detecting an uncooperative closure of any active // channels. // TODO(roasbeef): proper reconnection logic type peer struct { // The following fields are only meant to be used *atomically* bytesReceived uint64 bytesSent uint64 // pingTime is a rough estimate of the RTT (round-trip-time) between us // and the connected peer. This time is expressed in micro seconds. // TODO(roasbeef): also use a WMA or EMA? pingTime int64 // pingLastSend is the Unix time expressed in nanoseconds when we sent // our last ping message. pingLastSend int64 // MUST be used atomically. started int32 disconnect int32 connReq *connmgr.ConnReq conn net.Conn addr *lnwire.NetAddress pubKeyBytes [33]byte inbound bool id int32 // This mutex protects all the stats below it. sync.RWMutex timeConnected time.Time lastSend time.Time lastRecv time.Time // sendQueue is the channel which is used to queue outgoing to be // written onto the wire. Note that this channel is unbuffered. sendQueue chan outgoinMsg // sendQueueSync is a channel that's used to synchronize sends between // the queueHandler and the writeHandler. At times the writeHandler may // get blocked on sending messages. As a result we require a // synchronization mechanism between the two otherwise the queueHandler // would need to continually spin checking to see if the writeHandler // is ready for an additional message. sendQueueSync chan struct{} // outgoingQueue is a buffered channel which allows second/third party // objects to queue messages to be sent out on the wire. outgoingQueue chan outgoinMsg // activeChannels is a map which stores the state machines of all // active channels. Channels are indexed into the map by the txid of // the funding transaction which opened the channel. activeChanMtx sync.RWMutex activeChannels map[lnwire.ChannelID]*lnwallet.LightningChannel // newChannels is used by the fundingManager to send fully opened // channels to the source peer which handled the funding workflow. newChannels chan *newChannelMsg // localCloseChanReqs is a channel in which any local requests to close // a particular channel are sent over. localCloseChanReqs chan *htlcswitch.ChanClose // shutdownChanReqs is used to send the Shutdown messages that initiate // the cooperative close workflow. shutdownChanReqs chan *lnwire.Shutdown // closingSignedChanReqs is used to send signatures for proposed // channel close transactions during the cooperative close workflow. closingSignedChanReqs chan *lnwire.ClosingSigned server *server // localSharedFeatures is a product of comparison of our and their // local features vectors which consist of features which are present // on both sides. localSharedFeatures *lnwire.SharedFeatures // globalSharedFeatures is a product of comparison of our and their // global features vectors which consist of features which are present // on both sides. globalSharedFeatures *lnwire.SharedFeatures queueQuit chan struct{} quit chan struct{} wg sync.WaitGroup } // newPeer creates a new peer from an establish connection object, and a // pointer to the main server. func newPeer(conn net.Conn, connReq *connmgr.ConnReq, server *server, addr *lnwire.NetAddress, inbound bool) (*peer, error) { nodePub := addr.IdentityKey p := &peer{ conn: conn, addr: addr, id: atomic.AddInt32(&numNodes, 1), inbound: inbound, connReq: connReq, server: server, sendQueue: make(chan outgoinMsg), sendQueueSync: make(chan struct{}), outgoingQueue: make(chan outgoinMsg), activeChannels: make(map[lnwire.ChannelID]*lnwallet.LightningChannel), newChannels: make(chan *newChannelMsg, 1), localCloseChanReqs: make(chan *htlcswitch.ChanClose), shutdownChanReqs: make(chan *lnwire.Shutdown), closingSignedChanReqs: make(chan *lnwire.ClosingSigned), localSharedFeatures: nil, globalSharedFeatures: nil, queueQuit: make(chan struct{}), quit: make(chan struct{}), } copy(p.pubKeyBytes[:], nodePub.SerializeCompressed()) return p, nil } // Start starts all helper goroutines the peer needs for normal operations. In // the case this peer has already been started, then this function is a loop. func (p *peer) Start() error { if atomic.AddInt32(&p.started, 1) != 1 { return nil } peerLog.Tracef("peer %v starting", p) // Exchange local and global features, the init message should be very // first between two nodes. if err := p.sendInitMsg(); err != nil { return fmt.Errorf("unable to send init msg: %v", err) } // Before we launch any of the helper goroutines off the peer struct, // we'll first ensure proper adherence to the p2p protocol. The init // message MUST be sent before any other message. readErr := make(chan error, 1) msgChan := make(chan lnwire.Message, 1) p.wg.Add(1) go func() { defer p.wg.Done() msg, err := p.readNextMessage() if err != nil { readErr <- err msgChan <- nil return } readErr <- nil msgChan <- msg }() select { // In order to avoid blocking indefinitely, we'll give the other peer // an upper timeout of 15 seconds to respond before we bail out early. case <-time.After(time.Second * 15): return fmt.Errorf("peer did not complete handshake within 5 " + "seconds") case err := <-readErr: if err != nil { return fmt.Errorf("unable to read init msg: %v", err) } } // Once the init message arrives, we can parse it so we can figure out // the negotiation of features for this session. msg := <-msgChan if msg, ok := msg.(*lnwire.Init); ok { if err := p.handleInitMsg(msg); err != nil { return err } } else { return errors.New("very first message between nodes " + "must be init message") } // Fetch and then load all the active channels we have with this remote // peer from the database. activeChans, err := p.server.chanDB.FetchOpenChannels(p.addr.IdentityKey) if err != nil { peerLog.Errorf("unable to fetch active chans "+ "for peer %v: %v", p, err) return err } // Next, load all the active channels we have with this peer, // registering them with the switch and launching the necessary // goroutines required to operate them. peerLog.Debugf("Loaded %v active channels from database with "+ "peerID(%v)", len(activeChans), p.id) if err := p.loadActiveChannels(activeChans); err != nil { return fmt.Errorf("unable to load channels: %v", err) } p.wg.Add(5) go p.queueHandler() go p.writeHandler() go p.readHandler() go p.channelManager() go p.pingHandler() return nil } // loadActiveChannels creates indexes within the peer for tracking all active // channels returned by the database. func (p *peer) loadActiveChannels(chans []*channeldb.OpenChannel) error { for _, dbChan := range chans { // If the channel isn't yet open, then we don't need to process // it any further. if dbChan.IsPending { continue } lnChan, err := lnwallet.NewLightningChannel(p.server.cc.signer, p.server.cc.chainNotifier, p.server.cc.feeEstimator, dbChan) if err != nil { return err } chanPoint := &dbChan.FundingOutpoint // If the channel we read form disk has a nil next revocation // key, then we'll skip loading this channel. We must do this // as it doesn't yet have the needed items required to initiate // a local state transition, or one triggered by forwarding an // HTLC. if lnChan.RemoteNextRevocation() == nil { peerLog.Debugf("Skipping ChannelPoint(%v), lacking "+ "next commit point", chanPoint) continue } chanID := lnwire.NewChanIDFromOutPoint(chanPoint) p.activeChanMtx.Lock() p.activeChannels[chanID] = lnChan p.activeChanMtx.Unlock() peerLog.Infof("peerID(%v) loading ChannelPoint(%v)", p.id, chanPoint) select { case p.server.breachArbiter.newContracts <- lnChan: case <-p.server.quit: return fmt.Errorf("server shutting down") case <-p.quit: return fmt.Errorf("peer shutting down") } blockEpoch, err := p.server.cc.chainNotifier.RegisterBlockEpochNtfn() if err != nil { return err } _, currentHeight, err := p.server.cc.chainIO.GetBestBlock() if err != nil { return err } // Before we register this new link with the HTLC Switch, we'll // need to fetch its current link-layer forwarding policy from // the database. graph := p.server.chanDB.ChannelGraph() info, p1, p2, err := graph.FetchChannelEdgesByOutpoint(chanPoint) if err != nil && err != channeldb.ErrEdgeNotFound { return err } // We'll filter out our policy from the directional channel // edges based whom the edge connects to. If it doesn't connect // to us, then we know that we were the one that advertised the // policy. // // TODO(roasbeef): can add helper method to get policy for // particular channel. var selfPolicy *channeldb.ChannelEdgePolicy if info != nil && info.NodeKey1.IsEqual(p.server.identityPriv.PubKey()) { selfPolicy = p1 } else { selfPolicy = p2 } // If we don't yet have an advertised routing policy, then // we'll use the current default, otherwise we'll translate the // routing policy into a forwarding policy. var forwardingPolicy *htlcswitch.ForwardingPolicy if selfPolicy != nil { forwardingPolicy = &htlcswitch.ForwardingPolicy{ MinHTLC: selfPolicy.MinHTLC, BaseFee: selfPolicy.FeeBaseMSat, FeeRate: selfPolicy.FeeProportionalMillionths, TimeLockDelta: uint32(selfPolicy.TimeLockDelta), } } else { forwardingPolicy = &p.server.cc.routingPolicy } peerLog.Tracef("Using link policy of: %v", spew.Sdump(forwardingPolicy)) // Register this new channel link with the HTLC Switch. This is // necessary to properly route multi-hop payments, and forward // new payments triggered by RPC clients. linkCfg := htlcswitch.ChannelLinkConfig{ Peer: p, DecodeHopIterator: p.server.sphinx.DecodeHopIterator, DecodeOnionObfuscator: p.server.sphinx.ExtractErrorEncrypter, GetLastChannelUpdate: createGetLastUpdate(p.server.chanRouter, p.PubKey(), lnChan.ShortChanID()), SettledContracts: p.server.breachArbiter.settledContracts, DebugHTLC: cfg.DebugHTLC, HodlHTLC: cfg.HodlHTLC, Registry: p.server.invoices, Switch: p.server.htlcSwitch, FwrdingPolicy: *forwardingPolicy, BlockEpochs: blockEpoch, } link := htlcswitch.NewChannelLink(linkCfg, lnChan, uint32(currentHeight)) if err := p.server.htlcSwitch.AddLink(link); err != nil { return err } } return nil } // WaitForDisconnect waits until the peer has disconnected. A peer may be // disconnected if the local or remote side terminating the connection, or an // irrecoverable protocol error has been encountered. func (p *peer) WaitForDisconnect() { <-p.quit } // Disconnect terminates the connection with the remote peer. Additionally, a // signal is sent to the server and htlcSwitch indicating the resources // allocated to the peer can now be cleaned up. func (p *peer) Disconnect(reason error) { if !atomic.CompareAndSwapInt32(&p.disconnect, 0, 1) { return } peerLog.Tracef("Disconnecting %s, reason: %v", p, reason) // Ensure that the TCP connection is properly closed before continuing. p.conn.Close() close(p.quit) p.wg.Wait() } // String returns the string representation of this peer. func (p *peer) String() string { return p.conn.RemoteAddr().String() } // readNextMessage reads, and returns the next message on the wire along with // any additional raw payload. func (p *peer) readNextMessage() (lnwire.Message, error) { noiseConn, ok := p.conn.(*brontide.Conn) if !ok { return nil, fmt.Errorf("brontide.Conn required to read messages") } // First we'll read the next _full_ message. We do this rather than // reading incrementally from the stream as the Lightning wire protocol // is message oriented and allows nodes to pad on additional data to // the message stream. rawMsg, err := noiseConn.ReadNextMessage() atomic.AddUint64(&p.bytesReceived, uint64(len(rawMsg))) if err != nil { return nil, err } // Next, create a new io.Reader implementation from the raw message, // and use this to decode the message directly from. msgReader := bytes.NewReader(rawMsg) nextMsg, err := lnwire.ReadMessage(msgReader, 0) if err != nil { return nil, err } // TODO(roasbeef): add message summaries p.logWireMessage(nextMsg, true) return nextMsg, nil } // chanMsgStream implements a goroutine-safe, in-order stream of messages to be // delivered to an active channel. These messages MUST be in order due to the // nature of the lightning channel commitment state machine. We utilize // additional synchronization with the fundingManager to ensure we don't // attempt to dispatch a message to a channel before it is fully active. type chanMsgStream struct { fundingMgr *fundingManager htlcSwitch *htlcswitch.Switch cid lnwire.ChannelID peer *peer msgCond *sync.Cond msgs []lnwire.Message chanLink htlcswitch.ChannelLink mtx sync.Mutex wg sync.WaitGroup quit chan struct{} } // newChanMsgStream creates a new instance of a chanMsgStream for a particular // channel identified by its channel ID. func newChanMsgStream(f *fundingManager, h *htlcswitch.Switch, p *peer, c lnwire.ChannelID) *chanMsgStream { stream := &chanMsgStream{ fundingMgr: f, htlcSwitch: h, peer: p, cid: c, quit: make(chan struct{}), } stream.msgCond = sync.NewCond(&stream.mtx) return stream } // Start starts the chanMsgStream. func (c *chanMsgStream) Start() { c.wg.Add(1) go c.msgConsumer() } // Stop stops the chanMsgStream. func (c *chanMsgStream) Stop() { // TODO(roasbeef): signal too? close(c.quit) // Wake up the msgConsumer is we've been signalled to exit. c.msgCond.Signal() c.wg.Wait() } // msgConsumer is the main goroutine that streams messages from the peer's // readHandler directly to the target channel. func (c *chanMsgStream) msgConsumer() { defer c.wg.Done() peerLog.Tracef("Update stream for ChannelID(%x) created", c.cid[:]) for { // First, we'll check our condition. If the queue of messages // is empty, then we'll wait until a new item is added. c.msgCond.L.Lock() for len(c.msgs) == 0 { c.msgCond.Wait() // If we were woke up in order to exit, then we'll do // so. Otherwise, we'll check the message queue for any // new items. select { case <-c.quit: peerLog.Tracef("Update stream for "+ "ChannelID(%x) exiting", c.cid[:]) c.msgCond.L.Unlock() return default: } } // Grab the message off the front of the queue, shifting the // slice's reference down one in order to remove the message // from the queue. msg := c.msgs[0] c.msgs[0] = nil // Set to nil to prevent GC leak. c.msgs = c.msgs[1:] // We'll send a message to the funding manager and wait iff an // active funding process for this channel hasn't yet // completed. We do this in order to account for the following // scenario: we send the funding locked message to the other // side, they immediately send a channel update message, but we // haven't yet sent the channel to the channelManager. c.fundingMgr.waitUntilChannelOpen(c.cid) // Dispatch the commitment update message to the proper active // goroutine dedicated to this channel. if c.chanLink == nil { link, err := c.htlcSwitch.GetLink(c.cid) if err != nil { peerLog.Errorf("recv'd update for unknown "+ "channel %v from %v", c.cid, c.peer) continue } c.chanLink = link } c.chanLink.HandleChannelUpdate(msg) c.msgCond.L.Unlock() } } // AddMsg adds a new message to the chanMsgStream. This function is safe for // concurrent access. func (c *chanMsgStream) AddMsg(msg lnwire.Message) { // First, we'll lock the condition, and add the message to the end of // the message queue. c.msgCond.L.Lock() c.msgs = append(c.msgs, msg) c.msgCond.L.Unlock() // With the message added, we signal to the msgConsumer that there are // additional messages to consume. c.msgCond.Signal() } // readHandler is responsible for reading messages off the wire in series, then // properly dispatching the handling of the message to the proper subsystem. // // NOTE: This method MUST be run as a goroutine. func (p *peer) readHandler() { // We'll stop the timer after a new messages is received, and also // reset it after we process the next message. idleTimer := time.AfterFunc(idleTimeout, func() { err := fmt.Errorf("Peer %s no answer for %s -- disconnecting", p, idleTimeout) p.Disconnect(err) }) chanMsgStreams := make(map[lnwire.ChannelID]*chanMsgStream) out: for atomic.LoadInt32(&p.disconnect) == 0 { nextMsg, err := p.readNextMessage() idleTimer.Stop() if err != nil { peerLog.Infof("unable to read message from %v: %v", p, err) switch err.(type) { // If this is just a message we don't yet recognize, // we'll continue processing as normal as this allows // us to introduce new messages in a forwards // compatible manner. case *lnwire.UnknownMessage: idleTimer.Reset(idleTimeout) continue // If the error we encountered wasn't just a message we // didn't recognize, then we'll stop all processing s // this is a fatal error. default: break out } } var ( isChanUpdate bool targetChan lnwire.ChannelID ) switch msg := nextMsg.(type) { case *lnwire.Pong: // When we receive a Pong message in response to our // last ping message, we'll use the time in which we // sent the ping message to measure a rough estimate of // round trip time. pingSendTime := atomic.LoadInt64(&p.pingLastSend) delay := (time.Now().UnixNano() - pingSendTime) / 1000 atomic.StoreInt64(&p.pingTime, delay) case *lnwire.Ping: pongBytes := make([]byte, msg.NumPongBytes) p.queueMsg(lnwire.NewPong(pongBytes), nil) case *lnwire.OpenChannel: p.server.fundingMgr.processFundingOpen(msg, p.addr) case *lnwire.AcceptChannel: p.server.fundingMgr.processFundingAccept(msg, p.addr) case *lnwire.FundingCreated: p.server.fundingMgr.processFundingCreated(msg, p.addr) case *lnwire.FundingSigned: p.server.fundingMgr.processFundingSigned(msg, p.addr) case *lnwire.FundingLocked: p.server.fundingMgr.processFundingLocked(msg, p.addr) case *lnwire.Shutdown: select { case p.shutdownChanReqs <- msg: case <-p.quit: break out } case *lnwire.ClosingSigned: select { case p.closingSignedChanReqs <- msg: case <-p.quit: break out } case *lnwire.Error: p.server.fundingMgr.processFundingError(msg, p.addr) // TODO(roasbeef): create ChanUpdater interface for the below case *lnwire.UpdateAddHTLC: isChanUpdate = true targetChan = msg.ChanID case *lnwire.UpdateFufillHTLC: isChanUpdate = true targetChan = msg.ChanID case *lnwire.UpdateFailHTLC: isChanUpdate = true targetChan = msg.ChanID case *lnwire.RevokeAndAck: isChanUpdate = true targetChan = msg.ChanID case *lnwire.CommitSig: isChanUpdate = true targetChan = msg.ChanID case *lnwire.UpdateFee: isChanUpdate = true targetChan = msg.ChanID case *lnwire.ChannelUpdate, *lnwire.ChannelAnnouncement, *lnwire.NodeAnnouncement, *lnwire.AnnounceSignatures: p.server.authGossiper.ProcessRemoteAnnouncement(msg, p.addr.IdentityKey) default: peerLog.Errorf("unknown message %v received from peer "+ "%v", uint16(msg.MsgType()), p) } if isChanUpdate { // If this is a channel update, then we need to feed it // into the channel's in-order message stream. chanStream, ok := chanMsgStreams[targetChan] if !ok { // If a stream hasn't yet been created, then // we'll do so, add it to the map, and finally // start it. chanStream = newChanMsgStream(p.server.fundingMgr, p.server.htlcSwitch, p, targetChan) chanMsgStreams[targetChan] = chanStream chanStream.Start() } // With the stream obtained, add the message to the // stream so we can continue processing message. chanStream.AddMsg(nextMsg) } idleTimer.Reset(idleTimeout) } p.wg.Done() p.Disconnect(errors.New("read handler closed")) for cid, chanStream := range chanMsgStreams { chanStream.Stop() delete(chanMsgStreams, cid) } peerLog.Tracef("readHandler for peer %v done", p) } // logWireMessage logs the receipt or sending of particular wire message. This // function is used rather than just logging the message in order to produce // less spammy log messages in trace mode by setting the 'Curve" parameter to // nil. Doing this avoids printing out each of the field elements in the curve // parameters for secp256k1. func (p *peer) logWireMessage(msg lnwire.Message, read bool) { switch m := msg.(type) { case *lnwire.RevokeAndAck: m.NextRevocationKey.Curve = nil case *lnwire.NodeAnnouncement: m.NodeID.Curve = nil case *lnwire.ChannelAnnouncement: m.NodeID1.Curve = nil m.NodeID2.Curve = nil m.BitcoinKey1.Curve = nil m.BitcoinKey2.Curve = nil case *lnwire.AcceptChannel: m.FundingKey.Curve = nil m.RevocationPoint.Curve = nil m.PaymentPoint.Curve = nil m.DelayedPaymentPoint.Curve = nil m.FirstCommitmentPoint.Curve = nil case *lnwire.OpenChannel: m.FundingKey.Curve = nil m.RevocationPoint.Curve = nil m.PaymentPoint.Curve = nil m.DelayedPaymentPoint.Curve = nil m.FirstCommitmentPoint.Curve = nil case *lnwire.FundingLocked: m.NextPerCommitmentPoint.Curve = nil } prefix := "readMessage from" if !read { prefix = "writeMessage to" } peerLog.Tracef(prefix+" %v: %v", p, newLogClosure(func() string { return spew.Sdump(msg) })) } // writeMessage writes the target lnwire.Message to the remote peer. func (p *peer) writeMessage(msg lnwire.Message) error { // Simply exit if we're shutting down. if atomic.LoadInt32(&p.disconnect) != 0 { return nil } // TODO(roasbeef): add message summaries p.logWireMessage(msg, false) // As the Lightning wire protocol is fully message oriented, we only // allows one wire message per outer encapsulated crypto message. So // we'll create a temporary buffer to write the message directly to. var msgPayload [lnwire.MaxMessagePayload]byte b := bytes.NewBuffer(msgPayload[0:0:len(msgPayload)]) // With the temp buffer created and sliced properly (length zero, full // capacity), we'll now encode the message directly into this buffer. n, err := lnwire.WriteMessage(b, msg, 0) atomic.AddUint64(&p.bytesSent, uint64(n)) // TODO(roasbeef): add write deadline? // Finally, write the message itself in a single swoop. _, err = p.conn.Write(b.Bytes()) return err } // writeHandler is a goroutine dedicated to reading messages off of an incoming // queue, and writing them out to the wire. This goroutine coordinates with the // queueHandler in order to ensure the incoming message queue is quickly // drained. // // NOTE: This method MUST be run as a goroutine. func (p *peer) writeHandler() { var exitErr error out: for { select { case outMsg := <-p.sendQueue: switch outMsg.msg.(type) { // If we're about to send a ping message, then log the // exact time in which we send the message so we can // use the delay as a rough estimate of latency to the // remote peer. case *lnwire.Ping: // TODO(roasbeef): do this before the write? // possibly account for processing within func? now := time.Now().UnixNano() atomic.StoreInt64(&p.pingLastSend, now) } // Write out the message to the socket, closing the // 'sentChan' if it's non-nil, The 'sentChan' allows // callers to optionally synchronize sends with the // writeHandler. err := p.writeMessage(outMsg.msg) if outMsg.sentChan != nil { close(outMsg.sentChan) } if err != nil { exitErr = errors.Errorf("unable to write message: %v", err) break out } // If the queueHandler was waiting for us to complete // the last write, then we'll send it a sginal that // we're done and are awaiting additional messages. select { case p.sendQueueSync <- struct{}{}: default: } case <-p.quit: exitErr = errors.Errorf("peer exiting") break out } } p.wg.Done() p.Disconnect(exitErr) peerLog.Tracef("writeHandler for peer %v done", p) } // queueHandler is responsible for accepting messages from outside subsystems // to be eventually sent out on the wire by the writeHandler. // // NOTE: This method MUST be run as a goroutine. func (p *peer) queueHandler() { defer p.wg.Done() pendingMsgs := list.New() for { // Before add a queue'd message our pending message queue, // we'll first try to aggressively empty out our pending list of // messaging. drain: for { // Examine the front of the queue. If this message is // nil, then we've emptied out the queue and can accept // new messages from outside sub-systems. elem := pendingMsgs.Front() if elem == nil { break } select { case p.sendQueue <- elem.Value.(outgoinMsg): pendingMsgs.Remove(elem) case <-p.quit: return default: // If the write handler is currently blocked, // then we'll break out of this loop, to avoid // tightly spinning waiting for a blocked write // handler. break drain } } // If there weren't any messages to send, or the writehandler // is still blocked, then we'll accept a new message into the // queue from outside sub-systems. We'll also attempt to send // to the writeHandler again, as if this succeeds we'll once // again try to aggressively drain the pending message queue. select { case <-p.quit: return case msg := <-p.outgoingQueue: pendingMsgs.PushBack(msg) case <-p.sendQueueSync: // Fall through so we can go back to the top of the // drain loop. } } } // pingHandler is responsible for periodically sending ping messages to the // remote peer in order to keep the connection alive and/or determine if the // connection is still active. // // NOTE: This method MUST be run as a goroutine. func (p *peer) pingHandler() { defer p.wg.Done() pingTicker := time.NewTicker(pingInterval) defer pingTicker.Stop() // TODO(roasbeef): make dynamic in order to create fake cover traffic const numPingBytes = 16 out: for { select { case <-pingTicker.C: p.queueMsg(lnwire.NewPing(numPingBytes), nil) case <-p.quit: break out } } } // PingTime returns the estimated ping time to the peer in microseconds. func (p *peer) PingTime() int64 { return atomic.LoadInt64(&p.pingTime) } // queueMsg queues a new lnwire.Message to be eventually sent out on the // wire. func (p *peer) queueMsg(msg lnwire.Message, doneChan chan struct{}) { select { case p.outgoingQueue <- outgoinMsg{msg, doneChan}: case <-p.quit: return } } // ChannelSnapshots returns a slice of channel snapshots detailing all // currently active channels maintained with the remote peer. func (p *peer) ChannelSnapshots() []*channeldb.ChannelSnapshot { p.activeChanMtx.RLock() defer p.activeChanMtx.RUnlock() snapshots := make([]*channeldb.ChannelSnapshot, 0, len(p.activeChannels)) for _, activeChan := range p.activeChannels { snapshot := activeChan.StateSnapshot() snapshots = append(snapshots, snapshot) } return snapshots } // closingScripts are the set of clsoign deslivery scripts for each party. This // intermediate state is maintained for each active close negotiation, as the // final signatures sent must cover the specified delivery scripts for each // party. type closingScripts struct { localScript []byte remoteScript []byte } // channelManager is goroutine dedicated to handling all requests/signals // pertaining to the opening, cooperative closing, and force closing of all // channels maintained with the remote peer. // // NOTE: This method MUST be run as a goroutine. func (p *peer) channelManager() { defer p.wg.Done() // chanShutdowns is a map of channels for which our node has initiated // a cooperative channel close. When an lnwire.Shutdown is received, // this allows the node to determine the next step to be taken in the // workflow. chanShutdowns := make(map[lnwire.ChannelID]*htlcswitch.ChanClose) deliveryAddrs := make(map[lnwire.ChannelID]*closingScripts) // initiator[ShutdownSigs|FeeProposals] holds the // [signature|feeProposal] for the last ClosingSigned sent to the peer // by the initiator. This enables us to respond to subsequent steps in // the workflow without having to recalculate our signature for the // channel close transaction, and track the sent fee proposals for fee // negotiation purposes. initiatorShutdownSigs := make(map[lnwire.ChannelID][]byte) initiatorFeeProposals := make(map[lnwire.ChannelID]uint64) // responder[ShutdownSigs|FeeProposals] is similar to the the maps // above, just for the responder. responderShutdownSigs := make(map[lnwire.ChannelID][]byte) responderFeeProposals := make(map[lnwire.ChannelID]uint64) // TODO(roasbeef): move to cfg closure func genDeliveryScript := func() ([]byte, error) { deliveryAddr, err := p.server.cc.wallet.NewAddress( lnwallet.WitnessPubKey, false, ) if err != nil { return nil, err } peerLog.Infof("Delivery addr for channel close: %v", deliveryAddr) return txscript.PayToAddrScript(deliveryAddr) } out: for { select { // A new channel has arrived which means we've just completed a // funding workflow. We'll initialize the necessary local // state, and notify the htlc switch of a new link. case newChanReq := <-p.newChannels: chanPoint := newChanReq.channel.ChannelPoint() chanID := lnwire.NewChanIDFromOutPoint(chanPoint) newChan := newChanReq.channel // Make sure this channel is not already active. p.activeChanMtx.Lock() if _, ok := p.activeChannels[chanID]; ok { peerLog.Infof("Already have ChannelPoint(%v), ignoring.", chanPoint) p.activeChanMtx.Unlock() close(newChanReq.done) newChanReq.channel.Stop() continue } // If not already active, we'll add this channel to the set of active // channels, so we can look it up later easily // according to its channel ID. p.activeChannels[chanID] = newChan p.activeChanMtx.Unlock() peerLog.Infof("New channel active ChannelPoint(%v) "+ "with peerId(%v)", chanPoint, p.id) // Next, we'll assemble a ChannelLink along with the // necessary items it needs to function. // // TODO(roasbeef): panic on below? blockEpoch, err := p.server.cc.chainNotifier.RegisterBlockEpochNtfn() if err != nil { peerLog.Errorf("unable to register for block epoch: %v", err) continue } _, currentHeight, err := p.server.cc.chainIO.GetBestBlock() if err != nil { peerLog.Errorf("unable to get best block: %v", err) continue } linkConfig := htlcswitch.ChannelLinkConfig{ Peer: p, DecodeHopIterator: p.server.sphinx.DecodeHopIterator, DecodeOnionObfuscator: p.server.sphinx.ExtractErrorEncrypter, GetLastChannelUpdate: createGetLastUpdate(p.server.chanRouter, p.PubKey(), newChanReq.channel.ShortChanID()), SettledContracts: p.server.breachArbiter.settledContracts, DebugHTLC: cfg.DebugHTLC, HodlHTLC: cfg.HodlHTLC, Registry: p.server.invoices, Switch: p.server.htlcSwitch, FwrdingPolicy: p.server.cc.routingPolicy, BlockEpochs: blockEpoch, } link := htlcswitch.NewChannelLink(linkConfig, newChan, uint32(currentHeight)) // With the channel link created, we'll now notify the // htlc switch so this channel can be used to dispatch // local payments and also passively forward payments. if err := p.server.htlcSwitch.AddLink(link); err != nil { peerLog.Errorf("can't register new channel "+ "link(%v) with peerId(%v)", chanPoint, p.id) } close(newChanReq.done) // We've just received a local quest to close an active // channel. case req := <-p.localCloseChanReqs: // So we'll first transition the channel to a state of // pending shutdown. chanID := lnwire.NewChanIDFromOutPoint(req.ChanPoint) // We'll only track this shutdown request if this is a // regular close request, and not in response to a // channel breach. var ( deliveryScript []byte err error ) if req.CloseType == htlcswitch.CloseRegular { chanShutdowns[chanID] = req // As we need to close out the channel and // claim our funds on-chain, we'll request a // new delivery address from the wallet, and // turn that into it corresponding output // script. deliveryScript, err = genDeliveryScript() if err != nil { cErr := fmt.Errorf("Unable to generate "+ "delivery address: %v", err) peerLog.Errorf(cErr.Error()) req.Err <- cErr continue } // We'll also track this delivery script, as // we'll need it to reconstruct the cooperative // closure transaction during our closing fee // negotiation ratchet. deliveryAddrs[chanID] = &closingScripts{ localScript: deliveryScript, } } // With the state marked as shutting down, we can now // proceed with the channel close workflow. If this is // regular close, we'll send a shutdown. Otherwise, // we'll simply be clearing our indexes. p.handleLocalClose(req, deliveryScript) // A receipt of a message over this channel indicates that // either a shutdown proposal has been initiated, or a prior // one has been completed, advancing to the next state of // channel closure. case req := <-p.shutdownChanReqs: // If we don't have a channel that matches this channel // ID, then we'll ignore this message. chanID := req.ChannelID p.activeChanMtx.Lock() _, ok := p.activeChannels[chanID] p.activeChanMtx.Unlock() if !ok { peerLog.Warnf("Received unsolicited shutdown msg: %v", spew.Sdump(req)) continue } // First, we'll track their delivery script for when we // ultimately create the cooperative closure // transaction. deliveryScripts, ok := deliveryAddrs[chanID] if !ok { deliveryAddrs[chanID] = &closingScripts{} deliveryScripts = deliveryAddrs[chanID] } deliveryScripts.remoteScript = req.Address // Next, we'll check in the shutdown map to see if // we're the initiator or not. If we don't have an // entry for this channel, then this means that we're // the responder to the workflow. if _, ok := chanShutdowns[req.ChannelID]; !ok { // Check responderShutdownSigs for an already // existing shutdown signature for this channel. // If such a signature exists, it means we // already have sent a response to a shutdown // message for this channel, so ignore this one. _, exists := responderShutdownSigs[req.ChannelID] if exists { continue } // As we're the responder, we'll need to // generate a delivery script of our own. deliveryScript, err := genDeliveryScript() if err != nil { peerLog.Errorf("Unable to generate "+ "delivery address: %v", err) continue } deliveryScripts.localScript = deliveryScript // In this case, we'll send a shutdown message, // and also prep our closing signature for the // case the fees are immediately agreed upon. closeSig, proposedFee := p.handleShutdownResponse( req, deliveryScript) if closeSig != nil { responderShutdownSigs[req.ChannelID] = closeSig responderFeeProposals[req.ChannelID] = proposedFee } } // A receipt of a message over this channel indicates that the // final stage of a channel shutdown workflow has been // completed. case req := <-p.closingSignedChanReqs: // First we'll check if this has an entry in the local // shutdown map. chanID := req.ChannelID localCloseReq, ok := chanShutdowns[chanID] // If it does, then this means we were the initiator of // the channel shutdown procedure. if ok { shutdownSig := initiatorShutdownSigs[req.ChannelID] initiatorSig := append(shutdownSig, byte(txscript.SigHashAll)) // To finalize this shtudown, we'll now send a // matching close signed message to the other // party, and broadcast the closing transaction // to the network. If the fees are still being // negotiated, handleClosingSigned returns the // signature and proposed fee we sent to the // peer. In the case fee negotiation was // complete, and the closing tx was broadcasted, // closeSig will be nil, and we can delete the // state associated with this channel shutdown. closeSig, proposedFee := p.handleClosingSigned( localCloseReq, req, deliveryAddrs[chanID], initiatorSig, initiatorFeeProposals[req.ChannelID]) if closeSig != nil { initiatorShutdownSigs[req.ChannelID] = closeSig initiatorFeeProposals[req.ChannelID] = proposedFee } else { delete(initiatorShutdownSigs, req.ChannelID) delete(initiatorFeeProposals, req.ChannelID) delete(chanShutdowns, req.ChannelID) delete(deliveryAddrs, req.ChannelID) } continue } shutdownSig := responderShutdownSigs[req.ChannelID] responderSig := append(shutdownSig, byte(txscript.SigHashAll)) // Otherwise, we're the responder to the channel // shutdown procedure. The procedure will be the same, // but we don't have a local request to to notify about // updates, so just pass in nil instead. closeSig, proposedFee := p.handleClosingSigned(nil, req, deliveryAddrs[chanID], responderSig, responderFeeProposals[req.ChannelID]) if closeSig != nil { responderShutdownSigs[req.ChannelID] = closeSig responderFeeProposals[req.ChannelID] = proposedFee } else { delete(responderShutdownSigs, req.ChannelID) delete(responderFeeProposals, req.ChannelID) delete(deliveryAddrs, chanID) } case <-p.quit: break out } } } // handleLocalClose kicks-off the workflow to execute a cooperative or forced // unilateral closure of the channel initiated by a local subsystem. // // TODO(roasbeef): if no more active channels with peer call Remove on connMgr // with peerID func (p *peer) handleLocalClose(req *htlcswitch.ChanClose, deliveryScript []byte) { chanID := lnwire.NewChanIDFromOutPoint(req.ChanPoint) p.activeChanMtx.RLock() channel, ok := p.activeChannels[chanID] p.activeChanMtx.RUnlock() if !ok { err := fmt.Errorf("unable to close channel, ChannelID(%v) is "+ "unknown", chanID) peerLog.Errorf(err.Error()) req.Err <- err return } switch req.CloseType { // A type of CloseRegular indicates that the user has opted to close // out this channel on-chain, so we execute the cooperative channel // closure workflow. case htlcswitch.CloseRegular: err := p.sendShutdown(channel, deliveryScript) if err != nil { req.Err <- err return } // A type of CloseBreach indicates that the counterparty has breached // the channel therefore we need to clean up our local state. case htlcswitch.CloseBreach: // TODO(roasbeef): no longer need with newer beach logic? peerLog.Infof("ChannelPoint(%v) has been breached, wiping "+ "channel", req.ChanPoint) if err := p.WipeChannel(channel); err != nil { peerLog.Infof("Unable to wipe channel after detected "+ "breach: %v", err) req.Err <- err return } return } } // handleShutdownResponse is called when a responder in a cooperative channel // close workflow receives a Shutdown message. This is the second step in the // cooperative close workflow. This function generates a close transaction with // a proposed fee amount and sends the signed transaction to the initiator. // Returns the signature used to signed the close proposal, and the proposed // fee. func (p *peer) handleShutdownResponse(msg *lnwire.Shutdown, localDeliveryScript []byte) ([]byte, uint64) { p.activeChanMtx.RLock() channel, ok := p.activeChannels[msg.ChannelID] p.activeChanMtx.RUnlock() if !ok { peerLog.Errorf("unable to close channel, ChannelPoint(%v) is "+ "unknown", msg.ChannelID) return nil, 0 } // As we just received a shutdown message, we'll also send a shutdown // message with our desired fee so we can start the negotiation. err := p.sendShutdown(channel, localDeliveryScript) if err != nil { peerLog.Errorf("error while sending shutdown message: %v", err) return nil, 0 } // Calculate an initial proposed fee rate for the close transaction. feeRate := p.server.cc.feeEstimator.EstimateFeePerWeight(1) * 1000 // We propose a fee and send a close proposal to the peer. This will // start the fee negotiations. Once both sides agree on a fee, we'll // create a signature that closes the channel using the agreed upon fee. fee := channel.CalcFee(feeRate) closeSig, proposedFee, err := channel.CreateCloseProposal( fee, localDeliveryScript, msg.Address, ) if err != nil { peerLog.Errorf("unable to create close proposal: %v", err) return nil, 0 } parsedSig, err := btcec.ParseSignature(closeSig, btcec.S256()) if err != nil { peerLog.Errorf("unable to parse signature: %v", err) return nil, 0 } // With the closing signature assembled, we'll send the matching close // signed message to the other party so they can broadcast the closing // transaction if they agree with the fee, or create a new close // proposal if they don't. closingSigned := lnwire.NewClosingSigned(msg.ChannelID, proposedFee, parsedSig) p.queueMsg(closingSigned, nil) return closeSig, proposedFee } // calculateCompromiseFee performs the current fee negotiation algorithm, // taking into consideration our ideal fee based on current fee environment, // the fee we last proposed (if any), and the fee proposed by the peer. func calculateCompromiseFee(ourIdealFee, lastSentFee, peerFee uint64) uint64 { // We will accept a proposed fee in the interval // [0.5*ourIdealFee, 2*ourIdealFee]. If the peer's fee doesn't fall in // this range, we'll propose the average of the peer's fee and our last // sent fee, as long as it is in this range. // TODO(halseth): Dynamic fee to determine what we consider min/max for // timely confirmation. maxFee := 2 * ourIdealFee minFee := ourIdealFee / 2 // If we didn't propose a fee before, just use our ideal fee value for // the average calculation. if lastSentFee == 0 { lastSentFee = ourIdealFee } avgFee := (lastSentFee + peerFee) / 2 switch { case peerFee <= maxFee && peerFee >= minFee: // Peer fee is in the accepted range. return peerFee case avgFee <= maxFee && avgFee >= minFee: // The peer's fee is not in the accepted range, but the average // fee is. return avgFee case avgFee > maxFee: // TODO(halseth): We must ensure fee is not higher than the // current fee on the commitment transaction. // We cannot accept the average fee, as it is more than twice // our own estimate. Set our proposed to the maximum we can // accept. return maxFee default: // Cannot accept the average, as we consider it too low. return minFee } } // handleClosingSigned is called when the a ClosingSigned message is received // from the peer. If we are the initiator in the shutdown procedure, localReq // should be set to the local close request. If we are the responder, it should // be set to nil. // // This method sends the necessary ClosingSigned message to continue fee // negotiation, and in case we agreed on a fee completes the channel close // transaction, and then broadcasts it. It also performs channel cleanup (and // reports status back to the caller if this was a local shutdown request). // // It returns the signature and the proposed fee included in the ClosingSigned // sent to the peer. // // Following the broadcast, both the initiator and responder in the channel // closure workflow should watch the blockchain for a confirmation of the // closing transaction before considering the channel terminated. In the case // of an unresponsive remote party, the initiator can either choose to execute // a force closure, or backoff for a period of time, and retry the cooperative // closure. func (p *peer) handleClosingSigned(localReq *htlcswitch.ChanClose, msg *lnwire.ClosingSigned, deliveryScripts *closingScripts, lastSig []byte, lastFee uint64) ([]byte, uint64) { chanID := msg.ChannelID p.activeChanMtx.RLock() channel, ok := p.activeChannels[chanID] p.activeChanMtx.RUnlock() if !ok { err := fmt.Errorf("unable to close channel, ChannelID(%v) is "+ "unknown", chanID) peerLog.Errorf(err.Error()) if localReq != nil { localReq.Err <- err } return nil, 0 } // We now consider the fee proposed by the peer, together with the fee // we last proposed (if any). This method will in case more fee // negotiation is necessary send a new ClosingSigned message to the peer // with our new proposed fee. In case we can agree on a fee, it will // assemble the close transaction, and we can go on to broadcasting it. closeTx, ourSig, ourFee, err := p.negotiateFeeAndCreateCloseTx(channel, msg, deliveryScripts, lastSig, lastFee) if err != nil { if localReq != nil { localReq.Err <- err } return nil, 0 } // If closeTx == nil it means that we did not agree on a fee, but we // proposed a new fee to the peer. Return the signature used for this // new proposal, and the fee we proposed, for use when we get a reponse. if closeTx == nil { return ourSig, ourFee } chanPoint := channel.ChannelPoint() select { case p.server.breachArbiter.settledContracts <- chanPoint: case <-p.server.quit: return nil, 0 case <-p.quit: return nil, 0 } // We agreed on a fee, and we can broadcast the closure transaction to // the network. peerLog.Infof("Broadcasting cooperative close tx: %v", newLogClosure(func() string { return spew.Sdump(closeTx) })) if err := p.server.cc.wallet.PublishTransaction(closeTx); err != nil { // TODO(halseth): Add relevant error types to the // WalletController interface as this is quite fragile. if strings.Contains(err.Error(), "already exists") || strings.Contains(err.Error(), "already have") { peerLog.Infof("channel close tx from ChannelPoint(%v) "+ " already exist, probably broadcasted by peer: %v", chanPoint, err) } else { peerLog.Errorf("channel close tx from ChannelPoint(%v) "+ " rejected: %v", chanPoint, err) // TODO(roasbeef): send ErrorGeneric to other side return nil, 0 } } // Once we've completed the cooperative channel closure, we'll wipe the // channel so we reject any incoming forward or payment requests via // this channel. select { case p.server.breachArbiter.settledContracts <- chanPoint: case <-p.server.quit: return nil, 0 } if err := p.WipeChannel(channel); err != nil { if localReq != nil { localReq.Err <- err } return nil, 0 } // TODO(roasbeef): also add closure height to summary // Clear out the current channel state, marking the channel as being // closed within the database. closingTxid := closeTx.TxHash() chanInfo := channel.StateSnapshot() closeSummary := &channeldb.ChannelCloseSummary{ ChanPoint: *chanPoint, ClosingTXID: closingTxid, RemotePub: &chanInfo.RemoteIdentity, Capacity: chanInfo.Capacity, SettledBalance: chanInfo.LocalBalance.ToSatoshis(), CloseType: channeldb.CooperativeClose, IsPending: true, } if err := channel.DeleteState(closeSummary); err != nil { if localReq != nil { localReq.Err <- err } return nil, 0 } // If this is a locally requested shutdown, update the caller with a new // event detailing the current pending state of this request. if localReq != nil { localReq.Updates <- &lnrpc.CloseStatusUpdate{ Update: &lnrpc.CloseStatusUpdate_ClosePending{ ClosePending: &lnrpc.PendingUpdate{ Txid: closingTxid[:], }, }, } } _, bestHeight, err := p.server.cc.chainIO.GetBestBlock() if err != nil { if localReq != nil { localReq.Err <- err } return nil, 0 } // Finally, launch a goroutine which will request to be notified by the // ChainNotifier once the closure transaction obtains a single // confirmation. notifier := p.server.cc.chainNotifier // If any error happens during waitForChanToClose, forard it to // localReq. If this channel closure is not locally initiated, localReq // will be nil, so just ignore the error. errChan := make(chan error, 1) if localReq != nil { errChan = localReq.Err } go waitForChanToClose(uint32(bestHeight), notifier, errChan, chanPoint, &closingTxid, func() { // First, we'll mark the database as being fully closed // so we'll no longer watch for its ultimate closure // upon startup. err := p.server.chanDB.MarkChanFullyClosed(chanPoint) if err != nil { if localReq != nil { localReq.Err <- err } return } // Respond to the local subsystem which requested the // channel closure. if localReq != nil { localReq.Updates <- &lnrpc.CloseStatusUpdate{ Update: &lnrpc.CloseStatusUpdate_ChanClose{ ChanClose: &lnrpc.ChannelCloseUpdate{ ClosingTxid: closingTxid[:], Success: true, }, }, } } }) return nil, 0 } // negotiateFeeAndCreateCloseTx takes into consideration the closing transaction // fee proposed by the remote peer in the ClosingSigned message and our // previously proposed fee (set to 0 if no previous), and continues the fee // negotiation it process. In case the peer agreed on the same fee as we // previously sent, it will assemble the close transaction and broadcast it. In // case the peer propose a fee different from our previous proposal, but that // can be accepted, a ClosingSigned message with the accepted fee is sent, // before the closing transaction is broadcasted. In the case where we cannot // accept the peer's proposed fee, a new fee proposal will be sent. // // TODO(halseth): In the case where we cannot accept the fee, and we cannot // make more proposals, this method should return an error, and we should fail // the channel. func (p *peer) negotiateFeeAndCreateCloseTx(channel *lnwallet.LightningChannel, msg *lnwire.ClosingSigned, deliveryScripts *closingScripts, ourSig []byte, ourFeeProp uint64) (*wire.MsgTx, []byte, uint64, error) { peerFeeProposal := msg.FeeSatoshis // If the fee proposed by the peer is different from what we proposed // before (or we did not propose anything yet), we must check if we can // accept the proposal, or if we should negotiate. if peerFeeProposal != ourFeeProp { // The peer has suggested a different fee from what we proposed. // Let's calculate if this one is tolerable. ourIdealFeeRate := p.server.cc.feeEstimator. EstimateFeePerWeight(1) * 1000 ourIdealFee := channel.CalcFee(ourIdealFeeRate) fee := calculateCompromiseFee(ourIdealFee, ourFeeProp, peerFeeProposal) // Our new proposed fee must be strictly between what we // proposed before and what the peer proposed. isAcceptable := false if fee < peerFeeProposal && fee > ourFeeProp { isAcceptable = true } if fee < ourFeeProp && fee > peerFeeProposal { isAcceptable = true } if !isAcceptable { // TODO(halseth): fail channel } // Since the compromise fee is different from the fee we last // proposed, we must update our proposal. // Create a new close proposal with the compromise fee, and // send this to the peer. closeSig, proposedFee, err := channel.CreateCloseProposal(fee, deliveryScripts.localScript, deliveryScripts.remoteScript) if err != nil { peerLog.Errorf("unable to create close proposal: %v", err) return nil, nil, 0, err } parsedSig, err := btcec.ParseSignature(closeSig, btcec.S256()) if err != nil { peerLog.Errorf("unable to parse signature: %v", err) return nil, nil, 0, err } closingSigned := lnwire.NewClosingSigned(msg.ChannelID, proposedFee, parsedSig) p.queueMsg(closingSigned, nil) // If the compromise fee was different from what the peer // proposed, then we must return and wait for an answer, if not // we can go on to complete the close transaction. if fee != peerFeeProposal { return nil, closeSig, proposedFee, nil } // We accept the fee proposed by the peer, so prepare our // signature to complete the close transaction. ourSig = append(closeSig, byte(txscript.SigHashAll)) } // We agreed on a fee, and we have the peer's signature for this fee, // so we can assemble the close tx. peerSig := append(msg.Signature.Serialize(), byte(txscript.SigHashAll)) chanPoint := channel.ChannelPoint() closeTx, err := channel.CompleteCooperativeClose(ourSig, peerSig, deliveryScripts.localScript, deliveryScripts.remoteScript, peerFeeProposal) if err != nil { peerLog.Errorf("unable to complete cooperative "+ "close for ChannelPoint(%v): %v", chanPoint, err) // TODO(roasbeef): send ErrorGeneric to other side return nil, nil, 0, err } return closeTx, nil, 0, nil } // waitForChanToClose uses the passed notifier to wait until the channel has // been detected as closed on chain and then concludes by executing the // following actions: the channel point will be sent over the settleChan, and // finally the callback will be executed. If any error is encountered within // the function, then it will be sent over the errChan. func waitForChanToClose(bestHeight uint32, notifier chainntnfs.ChainNotifier, errChan chan error, chanPoint *wire.OutPoint, closingTxID *chainhash.Hash, cb func()) { peerLog.Infof("Waiting for confirmation of cooperative close of "+ "ChannelPoint(%v) with txid: %v", chanPoint, closingTxID) // TODO(roasbeef): add param for num needed confs confNtfn, err := notifier.RegisterConfirmationsNtfn(closingTxID, 1, bestHeight) if err != nil { if errChan != nil { errChan <- err } return } // In the case that the ChainNotifier is shutting down, all subscriber // notification channels will be closed, generating a nil receive. height, ok := <-confNtfn.Confirmed if !ok { return } // The channel has been closed, remove it from any active indexes, and // the database state. peerLog.Infof("ChannelPoint(%v) is now closed at "+ "height %v", chanPoint, height.BlockHeight) // Finally, execute the closure call back to mark the confirmation of // the transaction closing the contract. cb() } // sendShutdown handles the creation and sending of the Shutdown messages sent // between peers to initiate the cooperative channel close workflow. In // addition, sendShutdown also signals to the HTLC switch to stop accepting // HTLCs for the specified channel. func (p *peer) sendShutdown(channel *lnwallet.LightningChannel, deliveryScript []byte) error { // In order to construct the shutdown message, we'll need to // reconstruct the channelID, and the current set delivery script for // the channel closure. chanID := lnwire.NewChanIDFromOutPoint(channel.ChannelPoint()) // With both items constructed we'll now send the shutdown message for // this particular channel, advertising a shutdown request to our // desired closing script. shutdown := lnwire.NewShutdown(chanID, deliveryScript) p.queueMsg(shutdown, nil) // Finally, we'll unregister the link from the switch in order to // Prevent the HTLC switch from receiving additional HTLCs for this // channel. p.server.htlcSwitch.RemoveLink(chanID) return nil } // WipeChannel removes the passed channel from all indexes associated with the // peer, and deletes the channel from the database. func (p *peer) WipeChannel(channel *lnwallet.LightningChannel) error { channel.Stop() chanID := lnwire.NewChanIDFromOutPoint(channel.ChannelPoint()) p.activeChanMtx.Lock() delete(p.activeChannels, chanID) p.activeChanMtx.Unlock() // Instruct the Htlc Switch to close this link as the channel is no // longer active. if err := p.server.htlcSwitch.RemoveLink(chanID); err != nil { if err == htlcswitch.ErrChannelLinkNotFound { peerLog.Warnf("unable remove channel link with "+ "ChannelPoint(%v): %v", chanID, err) return nil } return err } return nil } // handleInitMsg handles the incoming init message which contains global and // local features vectors. If feature vectors are incompatible then disconnect. func (p *peer) handleInitMsg(msg *lnwire.Init) error { localSharedFeatures, err := p.server.localFeatures.Compare(msg.LocalFeatures) if err != nil { err := errors.Errorf("can't compare remote and local feature "+ "vectors: %v", err) peerLog.Error(err) return err } p.localSharedFeatures = localSharedFeatures globalSharedFeatures, err := p.server.globalFeatures.Compare(msg.GlobalFeatures) if err != nil { err := errors.Errorf("can't compare remote and global feature "+ "vectors: %v", err) peerLog.Error(err) return err } p.globalSharedFeatures = globalSharedFeatures return nil } // sendInitMsg sends init message to remote peer which contains our currently // supported local and global features. func (p *peer) sendInitMsg() error { msg := lnwire.NewInitMessage( p.server.globalFeatures, p.server.localFeatures, ) return p.writeMessage(msg) } // SendMessage queues a message for sending to the target peer. func (p *peer) SendMessage(msg lnwire.Message) error { p.queueMsg(msg, nil) return nil } // PubKey returns the pubkey of the peer in compressed serialized format. func (p *peer) PubKey() [33]byte { return p.pubKeyBytes } // TODO(roasbeef): make all start/stop mutexes a CAS // createGetLastUpdate returns the handler which serve as a source of the last // update of the channel in a form of lnwire update message. func createGetLastUpdate(router *routing.ChannelRouter, pubKey [33]byte, chanID lnwire.ShortChannelID) func() (*lnwire.ChannelUpdate, error) { return func() (*lnwire.ChannelUpdate, error) { info, edge1, edge2, err := router.GetChannelByID(chanID) if err != nil { return nil, err } if edge1 == nil || edge2 == nil { return nil, errors.Errorf("unable to find "+ "channel by ShortChannelID(%v)", chanID) } var local *channeldb.ChannelEdgePolicy if bytes.Compare(edge1.Node.PubKey.SerializeCompressed(), pubKey[:]) == 0 { local = edge2 } else { local = edge1 } update := &lnwire.ChannelUpdate{ Signature: local.Signature, ChainHash: info.ChainHash, ShortChannelID: lnwire.NewShortChanIDFromInt(local.ChannelID), Timestamp: uint32(local.LastUpdate.Unix()), Flags: local.Flags, TimeLockDelta: local.TimeLockDelta, HtlcMinimumMsat: local.MinHTLC, BaseFee: uint32(local.FeeBaseMSat), FeeRate: uint32(local.FeeProportionalMillionths), } hswcLog.Debugf("Sending latest channel_update: %v", spew.Sdump(update)) return update, nil } }