package routing import ( "bytes" "encoding/hex" "fmt" "sync" "sync/atomic" "time" "github.com/davecgh/go-spew/spew" "github.com/lightningnetwork/lnd/chainntnfs" "github.com/lightningnetwork/lnd/channeldb" "github.com/lightningnetwork/lnd/lnwallet" "github.com/lightningnetwork/lnd/lnwire" "github.com/roasbeef/btcd/btcec" "github.com/roasbeef/btcd/wire" "github.com/roasbeef/btcutil" "github.com/lightningnetwork/lightning-onion" ) // FeeSchema is the set fee configuration for a Lighting Node on the network. // Using the coefficients described within he schema, the required fee to // forward outgoing payments can be derived. // // TODO(roasbeef): should be in switch instead? type FeeSchema struct { // TODO(rosbeef): all these should be in msat instead // BaseFee is the base amount that will be chained for ANY payment // forwarded. BaseFee btcutil.Amount // FeeRate is the rate that will be charged for forwarding payments. // The fee rate has a granularity of 1/1000 th of a mili-satoshi, or a // millionth of a satoshi. FeeRate btcutil.Amount } // Config defines the configuration for the ChannelRouter. ALL elements within // the configuration MUST be non-nil for the ChannelRouter to carry out its // duties. type Config struct { // Graph is the channel graph that the ChannelRouter will use to gather // metrics from and also to carry out path finding queries. // TODO(roasbeef): make into an interface Graph *channeldb.ChannelGraph // Chain is the router's source to the most up-to-date blockchain data. // All incoming advertised channels will be checked against the chain // to ensure that the channels advertised are still open. // TODO(roasbeef): remove after discovery service is in Chain lnwallet.BlockChainIO // Notifier is an instance of the ChainNotifier that the router uses to // received notifications of incoming blocks. With each new incoming // block found, the router may be able to partially prune the channel // graph as channels may have been pruned. // TODO(roasbeef): could possibly just replace this with an epoch // channel. Notifier chainntnfs.ChainNotifier // FeeSchema is the set fee schema that will be announced on to the // network. // TODO(roasbeef): should either be in discovery or switch FeeSchema *FeeSchema // Broadcast is a function that is used to broadcast a particular set // of messages to all peers that the daemon is connected to. If // supplied, the exclude parameter indicates that the target peer should // be excluded from the broadcast. Broadcast func(exclude *btcec.PublicKey, msg ...lnwire.Message) error // SendMessages is a function which allows the ChannelRouter to send a // set of messages to a particular peer identified by the target public // key. SendMessages func(target *btcec.PublicKey, msg ...lnwire.Message) error // SendToSwitch is a function that directs a link-layer switch to // forward a fully encoded payment to the first hop in the route // denoted by its public key. A non-nil error is to be returned if the // payment was unsuccessful. SendToSwitch func(firstHop *btcec.PublicKey, htlcAdd *lnwire.UpdateAddHTLC) ([32]byte, error) } // ChannelRouter is the layer 3 router within the Lightning stack. Below the // ChannelRouter is the HtlcSwitch, and below that is the Bitcoin blockchain // itself. The primary role of the ChannelRouter is to respond to queries for // potential routes that can support a payment amount, and also general graph // reachability questions. The router will prune the channel graph // automatically as new blocks are discovered which spend certain known funding // outpoints, thereby closing their respective channels. Additionally, it's the // duty of the router to sync up newly connected peers with the latest state of // the channel graph. type ChannelRouter struct { sync.RWMutex // cfg is a copy of the configuration struct that the ChannelRouter was // initialized with. cfg *Config // selfNode is the center of the star-graph centered around the // ChannelRouter. The ChannelRouter uses this node as a starting point // when doing any path finding. selfNode *channeldb.LightningNode // TODO(roasbeef): make LRU, invalidate upon new block connect shortestPathCache map[[33]byte][]*Route nodeCache map[[33]byte]*channeldb.LightningNode edgeCache map[wire.OutPoint]*channeldb.ChannelEdge // newBlocks is a channel in which new blocks connected to the end of // the main chain are sent over. newBlocks <-chan *chainntnfs.BlockEpoch // networkMsgs is a channel that carries new network messages from // outside the ChannelRouter to be processed by the networkHandler. networkMsgs chan *routingMsg // syncRequests is a channel that carries requests to synchronize newly // connected peers to the state of the channel graph from our PoV. syncRequests chan *syncRequest // prematureAnnouncements maps a blockheight to a set of announcements // which are "premature" from our PoV. An announcement is premature if // it claims to be anchored in a block which is beyond the current // mainchain tip as we know it. Premature announcements will be // processed once the chain tip as we know it extends to/past the // premature height. // TODO(roasbeef): limit premature announcements to N prematureAnnouncements map[uint32][]lnwire.Message // bestHeight is the height of the block at the tip of the main chain // as we know it. bestHeight uint32 fakeSig *btcec.Signature started uint32 stopped uint32 quit chan struct{} wg sync.WaitGroup } // New creates a new instance of the ChannelRouter with the specified // configuration parameters. As part of initialization, if the router detects // that the channel graph isn't fully in sync with the latest UTXO (since the // channel graph is a subset of the UTXO set) set, then the router will proceed // to fully sync to the latest state of the UTXO set. func New(cfg Config) (*ChannelRouter, error) { // TODO(roasbeef): remove this place holder after sigs are properly // stored in the graph. s := "30450221008ce2bc69281ce27da07e6683571319d18e949ddfa2965fb6caa" + "1bf0314f882d70220299105481d63e0f4bc2a88121167221b6700d72a0e" + "ad154c03be696a292d24ae" fakeSigHex, err := hex.DecodeString(s) if err != nil { return nil, err } fakeSig, err := btcec.ParseSignature(fakeSigHex, btcec.S256()) if err != nil { return nil, err } selfNode, err := cfg.Graph.SourceNode() if err != nil { return nil, err } return &ChannelRouter{ cfg: &cfg, selfNode: selfNode, fakeSig: fakeSig, networkMsgs: make(chan *routingMsg), syncRequests: make(chan *syncRequest), prematureAnnouncements: make(map[uint32][]lnwire.Message), quit: make(chan struct{}), }, nil } // Start launches all the goroutines the ChannelRouter requires to carry out // its duties. If the router has already been started, then this method is a // noop. func (r *ChannelRouter) Start() error { if !atomic.CompareAndSwapUint32(&r.started, 0, 1) { return nil } log.Tracef("Channel Router starting") // First we register for new notifications of newly discovered blocks. // We do this immediately so we'll later be able to consume any/all // blocks which were discovered as we prune the channel graph using a // snapshot of the chain state. blockEpochs, err := r.cfg.Notifier.RegisterBlockEpochNtfn() if err != nil { return err } r.newBlocks = blockEpochs.Epochs _, height, err := r.cfg.Chain.GetBestBlock() if err != nil { return err } r.bestHeight = uint32(height) // Before we begin normal operation of the router, we first need to // synchronize the channel graph to the latest state of the UTXO set. if err := r.syncGraphWithChain(); err != nil { return err } r.wg.Add(1) go r.networkHandler() return nil } // Stop signals the ChannelRouter to gracefully halt all routines. This method // will *block* until all goroutines have excited. If the channel router has // already stopped then this method will return immediately. func (r *ChannelRouter) Stop() error { if !atomic.CompareAndSwapUint32(&r.stopped, 0, 1) { return nil } log.Infof("Channel Router shutting down") close(r.quit) r.wg.Wait() return nil } // syncGraphWithChain attempts to synchronize the current channel graph with // the latest UTXO set state. This process involves pruning from the channel // graph any channels which have been closed by spending their funding output // since we've been down. func (r *ChannelRouter) syncGraphWithChain() error { // First, we'll need to check to see if we're already in sync with the // latest state of the UTXO set. bestHash, bestHeight, err := r.cfg.Chain.GetBestBlock() if err != nil { return err } pruneHash, pruneHeight, err := r.cfg.Graph.PruneTip() if err != nil { switch { // If the graph has never been pruned, or hasn't fully been // created yet, then we don't treat this as an explicit error. case err == channeldb.ErrGraphNeverPruned: case err == channeldb.ErrGraphNotFound: default: return err } } log.Infof("Prune tip for Channel Graph: height=%v, hash=%v", pruneHeight, pruneHash) switch { // If the graph has never been pruned, then we can exit early as this // entails it's being created for the first time and hasn't seen any // block or created channels. case pruneHeight == 0 || pruneHash == nil: return nil // If the block hashes and heights match exactly, then we don't need to // prune the channel graph as we're already fully in sync. case bestHash.IsEqual(pruneHash) && uint32(bestHeight) == pruneHeight: return nil } log.Infof("Syncing channel graph from height=%v (hash=%v) to height=%v "+ "(hash=%v)", pruneHeight, pruneHash, bestHeight, bestHash) // If we're not yet caught up, then we'll walk forward in the chain in // the chain pruning the channel graph with each new block in the chain // that hasn't yet been consumed by the channel graph. var numChansClosed uint32 for nextHeight := pruneHeight + 1; nextHeight <= uint32(bestHeight); nextHeight++ { // Using the next height, fetch the next block to use in our // incremental graph pruning routine. nextHash, err := r.cfg.Chain.GetBlockHash(int64(nextHeight)) if err != nil { return err } nextBlock, err := r.cfg.Chain.GetBlock(nextHash) if err != nil { return err } // We're only interested in all prior outputs that've been // spent in the block, so collate all the referenced previous // outpoints within each tx and input. var spentOutputs []*wire.OutPoint for _, tx := range nextBlock.Transactions { for _, txIn := range tx.TxIn { spentOutputs = append(spentOutputs, &txIn.PreviousOutPoint) } } // With the spent outputs gathered, attempt to prune the // channel graph, also passing in the hash+height of the block // being pruned so the prune tip can be updated. numClosed, err := r.cfg.Graph.PruneGraph(spentOutputs, nextHash, nextHeight) if err != nil { return err } log.Infof("Block %v (height=%v) closed %v channels", nextHash, nextHeight, numClosed) numChansClosed += numClosed } log.Infof("Graph pruning complete: %v channels we're closed since "+ "height %v", numChansClosed, pruneHeight) return nil } // networkHandler is the primary goroutine for the ChannelRouter. The roles of // this goroutine include answering queries related to the state of the // network, syncing up newly connected peers, and also periodically // broadcasting our latest state to all connected peers. // // NOTE: This MUST be run as a goroutine. func (r *ChannelRouter) networkHandler() { defer r.wg.Done() var announcementBatch []lnwire.Message // TODO(roasbeef): parametrize the above trickleTimer := time.NewTicker(time.Millisecond * 300) defer trickleTimer.Stop() retransmitTimer := time.NewTicker(time.Minute * 30) defer retransmitTimer.Stop() for { select { // A new fully validated network message has just arrived. As a // result we'll modify the channel graph accordingly depending // on the exact type of the message. case netMsg := <-r.networkMsgs: // Process the network announcement to determine if // this is either a new announcement from our PoV or an // update to a prior vertex/edge we previously // accepted. accepted := r.processNetworkAnnouncement(netMsg.msg) // If the update was accepted, then add it to our next // announcement batch to be broadcast once the trickle // timer ticks gain. if accepted { announcementBatch = append(announcementBatch, netMsg.msg) } // TODO(roasbeef): remove all unconnected vertexes // after N blocks pass with no corresponding // announcements. // A new block has arrived, so we can prune the channel graph // of any channels which were closed in the block. case newBlock, ok := <-r.newBlocks: // If the channel has been closed, then this indicates // the daemon is shutting down, so we exit ourselves. if !ok { return } // Once a new block arrives, we update our running // track of the height of the chain tip. blockHeight := uint32(newBlock.Height) r.bestHeight = blockHeight // Next we check if we have any premature announcements // for this height, if so, then we process them once // more as normal announcements. prematureAnns := r.prematureAnnouncements[uint32(newBlock.Height)] if len(prematureAnns) != 0 { log.Infof("Re-processing %v premature announcements for "+ "height %v", len(prematureAnns), blockHeight) } for _, ann := range prematureAnns { if ok := r.processNetworkAnnouncement(ann); ok { announcementBatch = append(announcementBatch, ann) } } delete(r.prematureAnnouncements, blockHeight) log.Infof("Pruning channel graph using block %v (height=%v)", newBlock.Hash, blockHeight) block, err := r.cfg.Chain.GetBlock(newBlock.Hash) if err != nil { log.Errorf("unable to get block: %v", err) continue } // We're only interested in all prior outputs that've // been spent in the block, so collate all the // referenced previous outpoints within each tx and // input. var spentOutputs []*wire.OutPoint for _, tx := range block.Transactions { for _, txIn := range tx.TxIn { spentOutputs = append(spentOutputs, &txIn.PreviousOutPoint) } } // With the spent outputs gathered, attempt to prune // the channel graph, also passing in the hash+height // of the block being pruned so the prune tip can be // updated. numClosed, err := r.cfg.Graph.PruneGraph(spentOutputs, newBlock.Hash, blockHeight) if err != nil { log.Errorf("unable to prune routing table: %v", err) continue } log.Infof("Block %v (height=%v) closed %v channels", newBlock.Hash, blockHeight, numClosed) // The retransmission timer has ticked which indicates that we // should broadcast our personal channel to the network. This // addresses the case of channel advertisements whether being // dropped, or not properly propagated through the network. case <-retransmitTimer.C: var selfChans []lnwire.Message selfPub := r.selfNode.PubKey.SerializeCompressed() err := r.selfNode.ForEachChannel(nil, func(c *channeldb.ChannelEdge) error { chanNodePub := c.Node.PubKey.SerializeCompressed() // Compare our public key with that of the // channel peer. If our key is "less" than // theirs, then we're the "first" node in the // advertisement, otherwise we're the second. flags := uint16(1) if bytes.Compare(selfPub, chanNodePub) == -1 { flags = 0 } selfChans = append(selfChans, &lnwire.ChannelUpdateAnnouncement{ Signature: r.fakeSig, ChannelID: lnwire.NewChanIDFromInt(c.ChannelID), Timestamp: uint32(c.LastUpdate.Unix()), Flags: flags, Expiry: c.Expiry, HtlcMinimumMstat: uint32(c.MinHTLC), FeeBaseMstat: uint32(c.FeeBaseMSat), FeeProportionalMillionths: uint32(c.FeeProportionalMillionths), }) return nil }) if err != nil { log.Errorf("unable to retransmit "+ "channels: %v", err) continue } log.Infof("Retransmitting %v outgoing channels", len(selfChans)) // With all the wire messages properly crafted, we'll // broadcast our known outgoing channel to all our // immediate peers. if err := r.cfg.Broadcast(nil, selfChans...); err != nil { log.Errorf("unable to re-broadcast "+ "channels: %v", err) } // The trickle timer has ticked, which indicates we should // flush to the network the pending batch of new announcements // we've received since the last trickle tick. case <-trickleTimer.C: // If the current announcement batch is nil, then we // have no further work here. if len(announcementBatch) == 0 { continue } log.Infof("Broadcasting batch of %v new announcements", len(announcementBatch)) // If we have new things to announce then broadcast // then to all our immediately connected peers. err := r.cfg.Broadcast(nil, announcementBatch...) if err != nil { log.Errorf("unable to send batch announcement: %v", err) continue } // If we we're able to broadcast the current batch // successfully, then we reset the batch for a new // round of announcements. announcementBatch = nil // We've just received a new request to synchronize a peer with // our latest graph state. This indicates that a peer has just // connected for the first time, so for now we dump our entire // graph and allow them to sift through the (subjectively) new // information on their own. case syncReq := <-r.syncRequests: nodePub := syncReq.node.SerializeCompressed() log.Infof("Synchronizing channel graph with %x", nodePub) if err := r.syncChannelGraph(syncReq); err != nil { log.Errorf("unable to sync graph state with %x: %v", nodePub, err) } // The router has been signalled to exit, to we exit our main // loop so the wait group can be decremented. case <-r.quit: return } } } // processNetworkAnnouncement processes a new network relate authenticated // channel or node announcement. If the update didn't affect the internal state // of the draft due to either being out of date, invalid, or redundant, then // false is returned. Otherwise, true is returned indicating that the caller // may want to batch this request to be broadcast to immediate peers during the // next announcement epoch. func (r *ChannelRouter) processNetworkAnnouncement(msg lnwire.Message) bool { isPremature := func(chanID *lnwire.ChannelID) bool { return chanID.BlockHeight > r.bestHeight } switch msg := msg.(type) { // A new node announcement has arrived which either presents a new // node, or a node updating previously advertised information. case *lnwire.NodeAnnouncement: // Before proceeding ensure that we aren't already away of this // node, and if we are then this is a newer update that we // known of. lastUpdate, exists, err := r.cfg.Graph.HasLightningNode(msg.NodeID) if err != nil { log.Errorf("Unable to query for the existence of node: %v", err) return false } // If we've reached this pint then we're aware of th vertex // being advertised. So we now check if the new message has a // new time stamp, if not then we won't accept the new data as // it would override newer data. msgTimestamp := time.Unix(int64(msg.Timestamp), 0) if exists && lastUpdate.After(msgTimestamp) || lastUpdate.Equal(msgTimestamp) { log.Debugf("Ignoring outdated announcement for %x", msg.NodeID.SerializeCompressed()) return false } node := &channeldb.LightningNode{ LastUpdate: msgTimestamp, Address: msg.Address, PubKey: msg.NodeID, Alias: msg.Alias.String(), } if err = r.cfg.Graph.AddLightningNode(node); err != nil { log.Errorf("unable to add node %v: %v", msg.NodeID, err) return false } log.Infof("Updated vertex data for node=%x", msg.NodeID.SerializeCompressed()) // A new channel announcement has arrived, this indicates the // *creation* of a new channel within the graph. This only advertises // the existence of a channel and not yet the routing policies in // either direction of the channel. case *lnwire.ChannelAnnouncement: // Prior to processing the announcement we first check if we // already know of this channel, if so, then we can exit early. channelID := msg.ChannelID.ToUint64() _, _, exists, err := r.cfg.Graph.HasChannelEdge(channelID) if err != nil && err != channeldb.ErrGraphNoEdgesFound { log.Errorf("unable to check for edge existence: %v", err) return false } else if exists { log.Debugf("Ignoring announcement for known chan_id=%v", channelID) return false } // If the advertised inclusionary block is beyond our knowledge // of the chain tip, then we'll put the announcement in limbo // to be fully verified once we advance forward in the chain. if isPremature(&msg.ChannelID) { blockHeight := msg.ChannelID.BlockHeight log.Infof("Announcement for chan_id=(%v), is "+ "premature: advertises height %v, only height "+ "%v is known", channelID, msg.ChannelID.BlockHeight, r.bestHeight) r.prematureAnnouncements[blockHeight] = append( r.prematureAnnouncements[blockHeight], msg, ) return false } // Before we can add the channel to the channel graph, we need // to obtain the full funding outpoint that's encoded within // the channel ID. fundingPoint, err := r.fetchChanPoint(&msg.ChannelID) if err != nil { log.Errorf("unable to fetch chan point for chan_id=%v: %v", channelID, err) return false } // Now that we have the funding outpoint of the channel, ensure // that it hasn't yet been spent. If so, then this channel has // been closed so we'll ignore it. if _, err := r.cfg.Chain.GetUtxo(&fundingPoint.Hash, fundingPoint.Index); err != nil { log.Errorf("unable to fetch utxo for chan_id=%v: %v", channelID, err) return false } // TODO(roasbeef): also add capacity here two instead of on the // directed edges. err = r.cfg.Graph.AddChannelEdge(msg.FirstNodeID, msg.SecondNodeID, fundingPoint, channelID) if err != nil { log.Errorf("unable to add channel: %v", err) return false } log.Infof("New channel discovered! Link "+ "connects %x and %x with ChannelPoint(%v), chan_id=%v", msg.FirstNodeID.SerializeCompressed(), msg.SecondNodeID.SerializeCompressed(), fundingPoint, channelID) // A new authenticated channel update has has arrived, this indicates // that the directional information for an already known channel has // been updated. All updates are signed and validated before reaching // us, so we trust the data to be legitimate. case *lnwire.ChannelUpdateAnnouncement: chanID := msg.ChannelID.ToUint64() edge1Timestamp, edge2Timestamp, _, err := r.cfg.Graph.HasChannelEdge(chanID) if err != nil && err != channeldb.ErrGraphNoEdgesFound { log.Errorf("unable to check for edge existence: %v", err) return false } // If the advertised inclusionary block is beyond our knowledge // of the chain tip, then we'll put the announcement in limbo // to be fully verified once we advance forward in the chain. if isPremature(&msg.ChannelID) { blockHeight := msg.ChannelID.BlockHeight log.Infof("Update announcement for chan_id=(%v), is "+ "premature: advertises height %v, only height "+ "%v is known", chanID, blockHeight, r.bestHeight) r.prematureAnnouncements[blockHeight] = append( r.prematureAnnouncements[blockHeight], msg, ) return false } // As edges are directional edge node has a unique policy for // the direction of the edge they control. Therefore we first // check if we already have the most up to date information for // that edge. If so, then we can exit early. updateTimestamp := time.Unix(int64(msg.Timestamp), 0) switch msg.Flags { // A flag set of 0 indicates this is an announcement for // the "first" node in the channel. case 0: if edge1Timestamp.After(updateTimestamp) || edge1Timestamp.Equal(updateTimestamp) { log.Debugf("Ignoring announcement (flags=%v) "+ "for known chan_id=%v", msg.Flags, chanID) return false } // Similarly, a flag set of 1 indicates this is an // announcement for the "second" node in the channel. case 1: if edge2Timestamp.After(updateTimestamp) || edge2Timestamp.Equal(updateTimestamp) { log.Debugf("Ignoring announcement (flags=%v) "+ "for known chan_id=%v", msg.Flags, chanID) return false } } // Before we can update the channel information, we need to get // the UTXO itself so we can store the proper capacity. chanPoint, err := r.fetchChanPoint(&msg.ChannelID) if err != nil { log.Errorf("unable to fetch chan point for chan_id=%v: %v", chanID, err) return false } utxo, err := r.cfg.Chain.GetUtxo(&chanPoint.Hash, chanPoint.Index) if err != nil { log.Errorf("unable to fetch utxo for chan_id=%v: %v", chanID, err) return false } // TODO(roasbeef): should be msat here chanUpdate := &channeldb.ChannelEdge{ ChannelID: chanID, ChannelPoint: *chanPoint, LastUpdate: updateTimestamp, Flags: msg.Flags, Expiry: msg.Expiry, MinHTLC: btcutil.Amount(msg.HtlcMinimumMstat), FeeBaseMSat: btcutil.Amount(msg.FeeBaseMstat), FeeProportionalMillionths: btcutil.Amount(msg.FeeProportionalMillionths), // TODO(roasbeef): this is a hack, needs to be removed // after commitment fees are dynamic. Capacity: btcutil.Amount(utxo.Value) - btcutil.Amount(5000), } err = r.cfg.Graph.UpdateEdgeInfo(chanUpdate) if err != nil { log.Errorf("unable to add channel: %v", err) return false } log.Infof("New channel update applied: %v", spew.Sdump(chanUpdate)) } return true } // syncRequest represents a request from an outside subsystem to the wallet to // sync a new node to the latest graph state. type syncRequest struct { node *btcec.PublicKey } // SynchronizeNode sends a message to the ChannelRouter indicating it should // synchronize routing state with the target node. This method is to be // utilized when a node connections for the first time to provide it with the // latest channel graph state. func (r *ChannelRouter) SynchronizeNode(pub *btcec.PublicKey) { select { case r.syncRequests <- &syncRequest{ node: pub, }: case <-r.quit: return } } // syncChannelGraph attempts to synchronize the target node in the syncReq to // the latest channel graph state. In order to accomplish this, (currently) the // entire graph is read from disk, then serialized to the format defined within // the current wire protocol. This cache of graph data is then sent directly to // the target node. func (r *ChannelRouter) syncChannelGraph(syncReq *syncRequest) error { targetNode := syncReq.node // TODO(roasbeef): need to also store sig data in db // * will be nice when we switch to pairing sigs would only need one ^_^ // We'll collate all the gathered routing messages into a single slice // containing all the messages to be sent to the target peer. var announceMessages []lnwire.Message // First run through all the vertexes in the graph, retrieving the data // for the announcement we originally retrieved. var numNodes uint32 if err := r.cfg.Graph.ForEachNode(func(node *channeldb.LightningNode) error { alias, err := lnwire.NewAlias(node.Alias) if err != nil { return err } ann := &lnwire.NodeAnnouncement{ Signature: r.fakeSig, Timestamp: uint32(node.LastUpdate.Unix()), Address: node.Address, NodeID: node.PubKey, Alias: alias, } announceMessages = append(announceMessages, ann) numNodes++ return nil }); err != nil { return err } // With the vertexes gathered, we'll no retrieve the initial // announcement, as well as the latest channel update announcement for // both of the directed edges that make up the channel. // TODO(roasbeef): multi-sig keys should also be stored in DB var numEdges uint32 if err := r.cfg.Graph.ForEachChannel(func(e1, e2 *channeldb.ChannelEdge) error { // First we'll need to obtain the channel ID for the channel // advertisement. As an edge may not be advertised, we'll grab // the channel ID from the edge that was. var chanID lnwire.ChannelID switch { case e1 != nil: chanID = lnwire.NewChanIDFromInt(e1.ChannelID) case e2 != nil: chanID = lnwire.NewChanIDFromInt(e2.ChannelID) case e1 == nil && e2 == nil: return nil default: chanID = lnwire.NewChanIDFromInt(e1.ChannelID) } chanAnn := &lnwire.ChannelAnnouncement{ FirstNodeSig: r.fakeSig, SecondNodeSig: r.fakeSig, ChannelID: chanID, FirstBitcoinSig: r.fakeSig, SecondBitcoinSig: r.fakeSig, } // If the edge was advertised, then we'll use the node's // identity within the announcement we send to the sync node. // Otherwise, we'll fill in a dummy key. // // TODO(roasbeef): both else clauses need to be removed // once we fully validate, andrew's PR will reconcile // this if e1 != nil { chanAnn.FirstNodeID = e1.Node.PubKey chanAnn.FirstBitcoinKey = e1.Node.PubKey } else { chanAnn.FirstNodeID = e2.Node.PubKey chanAnn.FirstBitcoinKey = e2.Node.PubKey } if e2 != nil { chanAnn.SecondNodeID = e2.Node.PubKey chanAnn.SecondBitcoinKey = e2.Node.PubKey } else { chanAnn.SecondNodeID = e1.Node.PubKey chanAnn.SecondBitcoinKey = e1.Node.PubKey } // We'll unconditionally queue the channel's existence proof as // it will need to be processed before either of the channel // update announcements. announceMessages = append(announceMessages, chanAnn) // Since it's up to a node's policy as to whether they // advertise the edge in dire direction, we don't create an // advertisement if the edge is nil. if e1 != nil { announceMessages = append(announceMessages, &lnwire.ChannelUpdateAnnouncement{ Signature: r.fakeSig, ChannelID: chanID, Timestamp: uint32(e1.LastUpdate.Unix()), Flags: 0, Expiry: e1.Expiry, HtlcMinimumMstat: uint32(e1.MinHTLC), FeeBaseMstat: uint32(e1.FeeBaseMSat), FeeProportionalMillionths: uint32(e1.FeeProportionalMillionths), }) } if e2 != nil { announceMessages = append(announceMessages, &lnwire.ChannelUpdateAnnouncement{ Signature: r.fakeSig, ChannelID: chanID, Timestamp: uint32(e2.LastUpdate.Unix()), Flags: 1, Expiry: e2.Expiry, HtlcMinimumMstat: uint32(e2.MinHTLC), FeeBaseMstat: uint32(e2.FeeBaseMSat), FeeProportionalMillionths: uint32(e2.FeeProportionalMillionths), }) } numEdges++ return nil }); err != nil && err != channeldb.ErrGraphNoEdgesFound { log.Errorf("unable to sync edges w/ peer: %v", err) return err } log.Infof("Syncing channel graph state with %x, sending %v "+ "nodes and %v edges", targetNode.SerializeCompressed(), numNodes, numEdges) // With all the announcement messages gathered, send them all in a // single batch to the target peer. return r.cfg.SendMessages(targetNode, announceMessages...) } // fetchChanPoint retrieves the original outpoint which is encoded within the // channelID. func (r *ChannelRouter) fetchChanPoint(chanID *lnwire.ChannelID) (*wire.OutPoint, error) { // First fetch the block hash by the block number encoded, then use // that hash to fetch the block itself. blockNum := int64(chanID.BlockHeight) blockHash, err := r.cfg.Chain.GetBlockHash(blockNum) if err != nil { return nil, err } fundingBlock, err := r.cfg.Chain.GetBlock(blockHash) if err != nil { return nil, err } // As a sanity check, ensure that the advertised transaction index is // within the bounds of the total number of transactions within a // block. numTxns := uint32(len(fundingBlock.Transactions)) if chanID.TxIndex > numTxns-1 { return nil, fmt.Errorf("tx_index=#%v is out of range "+ "(max_index=%v), network_chan_id=%v\n", chanID.TxIndex, numTxns-1, spew.Sdump(chanID)) } // TODO(roasbeef): skipping validation here as the discovery service // should handle full validate // Finally once we have the block itself, we seek to the targeted // transaction index to obtain the funding output and txid. fundingTx := fundingBlock.Transactions[chanID.TxIndex] return &wire.OutPoint{ Hash: fundingTx.TxHash(), Index: uint32(chanID.TxPosition), }, nil } // routingMsg couples a routing related wire message with the peer that // originally sent it. type routingMsg struct { msg lnwire.Message peer *btcec.PublicKey } // ProcessRoutingMessags sends a new routing message along with the peer that // sent the routing message to the ChannelRouter. The announcement will be // processed then added to a queue for batched tickled announcement to all // connected peers. // // TODO(roasbeef): need to move to discovery package func (r *ChannelRouter) ProcessRoutingMessage(msg lnwire.Message, src *btcec.PublicKey) { // TODO(roasbeef): msg wrappers to add a doneChan rMsg := &routingMsg{ msg: msg, peer: src, } select { case r.networkMsgs <- rMsg: case <-r.quit: return } } // FindRoute attempts to query the ChannelRouter for the "best" path to a // particular target destination which is able to send `amt` after factoring in // channel capacities and cumulative fees along the route. func (r *ChannelRouter) FindRoute(target *btcec.PublicKey, amt btcutil.Amount) (*Route, error) { dest := target.SerializeCompressed() log.Debugf("Searching for path to %x, sending %v", dest, amt) // We can short circuit the routing by opportunistically checking to // see if the target vertex event exists in the current graph. if _, exists, err := r.cfg.Graph.HasLightningNode(target); err != nil { return nil, err } else if !exists { log.Debugf("Target %x is not in known graph", dest) return nil, ErrTargetNotInNetwork } // TODO(roasbeef): add k-shortest paths route, err := findRoute(r.cfg.Graph, target, amt) if err != nil { log.Errorf("Unable to find path: %v", err) return nil, err } // TODO(roabseef): also create the Sphinx packet and add in the route log.Debugf("Obtained path sending %v to %x: %v", amt, dest, newLogClosure(func() string { return spew.Sdump(route) }), ) return route, nil } // generateSphinxPacket generates then encodes a sphinx packet which encodes // the onion route specified by the passed layer 3 route. The blob returned // from this function can immediately be included within an HTLC add packet to // be sent to the first hop within the route. // // TODO(roasbeef): add params for the per-hop payloads func generateSphinxPacket(route *Route, paymentHash []byte) ([]byte, error) { // First obtain all the public keys along the route which are contained // in each hop. nodes := make([]*btcec.PublicKey, len(route.Hops)) for i, hop := range route.Hops { // We create a new instance of the public key to avoid possibly // mutating the curve parameters, which are unset in a higher // level in order to avoid spamming the logs. pub := btcec.PublicKey{ Curve: btcec.S256(), X: hop.Channel.Node.PubKey.X, Y: hop.Channel.Node.PubKey.Y, } nodes[i] = &pub } // Next we generate the per-hop payload which gives each node within // the route the necessary information (fees, CLTV value, etc) to // properly forward the payment. // TODO(roasbeef): properly set CLTV value, payment amount, and chain // within hop payloads. var hopPayloads [][]byte for i := 0; i < len(route.Hops); i++ { payload := bytes.Repeat([]byte{byte('A' + i)}, sphinx.HopPayloadSize) hopPayloads = append(hopPayloads, payload) } sessionKey, err := btcec.NewPrivateKey(btcec.S256()) if err != nil { return nil, err } // Next generate the onion routing packet which allows us to perform // privacy preserving source routing across the network. sphinxPacket, err := sphinx.NewOnionPacket(nodes, sessionKey, hopPayloads, paymentHash) if err != nil { return nil, err } // Finally, encode Sphinx packet using it's wire representation to be // included within the HTLC add packet. var onionBlob bytes.Buffer if err := sphinxPacket.Encode(&onionBlob); err != nil { return nil, err } log.Tracef("Generated sphinx packet: %v", newLogClosure(func() string { // We unset the internal curve here in order to keep // the logs from getting noisy. sphinxPacket.Header.EphemeralKey.Curve = nil return spew.Sdump(sphinxPacket) }), ) return onionBlob.Bytes(), nil } // LightningPayment describes a payment to be sent through the network to the // final destination. type LightningPayment struct { // Target is the node in which the payment should be routed towards. Target *btcec.PublicKey // Amount is the value of the payment to send throuhg the network in // satoshis. // TODO(roasbeef): this should be milli satoshis Amount btcutil.Amount // PaymentHash is the r-hash value to use within the HTLC extended to // the first hop. PaymentHash [32]byte // TODO(roasbeef): add message? } // SendPayment attempts to send a payment as described within the passed // LightningPayment. This function is blocking and will return either: when the // payment is successful, or all candidates routes have been attempted and // resulted in a failed payment. If the payment succeeds, then a non-nil Route // will be returned which describes the path the successful payment traversed // within the network to reach the destination. Additionally, the payment // preimage will also be returned. func (r *ChannelRouter) SendPayment(payment *LightningPayment) ([32]byte, *Route, error) { var ( err error preImage [32]byte ) // Query the graph for a potential path to the destination node that // can support our payment amount. If a path is ultimately unavailable, // then an error will be returned. route, err := r.FindRoute(payment.Target, payment.Amount) if err != nil { return preImage, nil, err } log.Tracef("Selected route for payment: %#v", route) // Generate the raw encoded sphinx packet to be included along with the // htlcAdd message that we send directly to the switch. sphinxPacket, err := generateSphinxPacket(route, payment.PaymentHash[:]) if err != nil { return preImage, nil, err } // Craft an HTLC packet to send to the layer 2 switch. The metadata // within this packet will be used to route the payment through the // network, starting with the first-hop. htlcAdd := &lnwire.UpdateAddHTLC{ Amount: route.TotalAmount, PaymentHash: payment.PaymentHash, } copy(htlcAdd.OnionBlob[:], sphinxPacket) // Attempt to send this payment through the network to complete the // payment. If this attempt fails, then we'll bail our early. firstHop := route.Hops[0].Channel.Node.PubKey preImage, err = r.cfg.SendToSwitch(firstHop, htlcAdd) if err != nil { return preImage, nil, err } return preImage, route, nil } // TopologyClient... // TODO(roasbeef): put in discovery package? type TopologyClient struct { } // TopologyChange... type TopologyChange struct { NewNodes []*channeldb.LinkNode NewChannels []*channeldb.ChannelEdge } // notifyTopologyChange... func (r *ChannelRouter) notifyTopologyChange() { } // SubscribeTopology.... func (r *ChannelRouter) SubscribeTopology() (*TopologyClient, error) { return nil, nil }