diff --git a/chan_series.go b/chan_series.go deleted file mode 100644 index 7f592503..00000000 --- a/chan_series.go +++ /dev/null @@ -1,312 +0,0 @@ -package main - -import ( - "time" - - "github.com/btcsuite/btcd/chaincfg/chainhash" - "github.com/lightningnetwork/lnd/channeldb" - "github.com/lightningnetwork/lnd/discovery" - "github.com/lightningnetwork/lnd/lnwire" - "github.com/lightningnetwork/lnd/routing" -) - -// chanSeries is an implementation of the discovery.ChannelGraphTimeSeries -// interface backed by the channeldb ChannelGraph database. We'll provide this -// implementation to the AuthenticatedGossiper so it can properly use the -// in-protocol channel range queries to quickly and efficiently synchronize our -// channel state with all peers. -type chanSeries struct { - graph *channeldb.ChannelGraph -} - -// HighestChanID should return is the channel ID of the channel we know of -// that's furthest in the target chain. This channel will have a block height -// that's close to the current tip of the main chain as we know it. We'll use -// this to start our QueryChannelRange dance with the remote node. -// -// NOTE: This is part of the discovery.ChannelGraphTimeSeries interface. -func (c *chanSeries) HighestChanID(chain chainhash.Hash) (*lnwire.ShortChannelID, error) { - chanID, err := c.graph.HighestChanID() - if err != nil { - return nil, err - } - - shortChanID := lnwire.NewShortChanIDFromInt(chanID) - return &shortChanID, nil -} - -// UpdatesInHorizon returns all known channel and node updates with an update -// timestamp between the start time and end time. We'll use this to catch up a -// remote node to the set of channel updates that they may have missed out on -// within the target chain. -// -// NOTE: This is part of the discovery.ChannelGraphTimeSeries interface. -func (c *chanSeries) UpdatesInHorizon(chain chainhash.Hash, - startTime time.Time, endTime time.Time) ([]lnwire.Message, error) { - - var updates []lnwire.Message - - // First, we'll query for all the set of channels that have an update - // that falls within the specified horizon. - chansInHorizon, err := c.graph.ChanUpdatesInHorizon( - startTime, endTime, - ) - if err != nil { - return nil, err - } - for _, channel := range chansInHorizon { - // If the channel hasn't been fully advertised yet, or is a - // private channel, then we'll skip it as we can't construct a - // full authentication proof if one is requested. - if channel.Info.AuthProof == nil { - continue - } - - chanAnn, edge1, edge2, err := discovery.CreateChanAnnouncement( - channel.Info.AuthProof, channel.Info, channel.Policy1, - channel.Policy2, - ) - if err != nil { - return nil, err - } - - updates = append(updates, chanAnn) - if edge1 != nil { - updates = append(updates, edge1) - } - if edge2 != nil { - updates = append(updates, edge2) - } - } - - // Next, we'll send out all the node announcements that have an update - // within the horizon as well. We send these second to ensure that they - // follow any active channels they have. - nodeAnnsInHorizon, err := c.graph.NodeUpdatesInHorizon( - startTime, endTime, - ) - if err != nil { - return nil, err - } - for _, nodeAnn := range nodeAnnsInHorizon { - // Ensure we only forward nodes that are publicly advertised to - // prevent leaking information about nodes. - isNodePublic, err := c.graph.IsPublicNode(nodeAnn.PubKeyBytes) - if err != nil { - srvrLog.Errorf("Unable to determine if node %x is "+ - "advertised: %v", nodeAnn.PubKeyBytes, err) - continue - } - - if !isNodePublic { - srvrLog.Tracef("Skipping forwarding announcement for "+ - "node %x due to being unadvertised", - nodeAnn.PubKeyBytes) - continue - } - - nodeUpdate, err := nodeAnn.NodeAnnouncement(true) - if err != nil { - return nil, err - } - - updates = append(updates, nodeUpdate) - } - - return updates, nil -} - -// FilterKnownChanIDs takes a target chain, and a set of channel ID's, and -// returns a filtered set of chan ID's. This filtered set of chan ID's -// represents the ID's that we don't know of which were in the passed superSet. -// -// NOTE: This is part of the discovery.ChannelGraphTimeSeries interface. -func (c *chanSeries) FilterKnownChanIDs(chain chainhash.Hash, - superSet []lnwire.ShortChannelID) ([]lnwire.ShortChannelID, error) { - - chanIDs := make([]uint64, 0, len(superSet)) - for _, chanID := range superSet { - chanIDs = append(chanIDs, chanID.ToUint64()) - } - - newChanIDs, err := c.graph.FilterKnownChanIDs(chanIDs) - if err != nil { - return nil, err - } - - filteredIDs := make([]lnwire.ShortChannelID, 0, len(newChanIDs)) - for _, chanID := range newChanIDs { - filteredIDs = append( - filteredIDs, lnwire.NewShortChanIDFromInt(chanID), - ) - } - - return filteredIDs, nil -} - -// FilterChannelRange returns the set of channels that we created between the -// start height and the end height. We'll use this respond to a remote peer's -// QueryChannelRange message. -// -// NOTE: This is part of the discovery.ChannelGraphTimeSeries interface. -func (c *chanSeries) FilterChannelRange(chain chainhash.Hash, - startHeight, endHeight uint32) ([]lnwire.ShortChannelID, error) { - - chansInRange, err := c.graph.FilterChannelRange(startHeight, endHeight) - if err != nil { - return nil, err - } - - chanResp := make([]lnwire.ShortChannelID, 0, len(chansInRange)) - for _, chanID := range chansInRange { - chanResp = append( - chanResp, lnwire.NewShortChanIDFromInt(chanID), - ) - } - - return chanResp, nil -} - -// FetchChanAnns returns a full set of channel announcements as well as their -// updates that match the set of specified short channel ID's. We'll use this -// to reply to a QueryShortChanIDs message sent by a remote peer. The response -// will contain a unique set of ChannelAnnouncements, the latest ChannelUpdate -// for each of the announcements, and a unique set of NodeAnnouncements. -// -// NOTE: This is part of the discovery.ChannelGraphTimeSeries interface. -func (c *chanSeries) FetchChanAnns(chain chainhash.Hash, - shortChanIDs []lnwire.ShortChannelID) ([]lnwire.Message, error) { - - chanIDs := make([]uint64, 0, len(shortChanIDs)) - for _, chanID := range shortChanIDs { - chanIDs = append(chanIDs, chanID.ToUint64()) - } - - channels, err := c.graph.FetchChanInfos(chanIDs) - if err != nil { - return nil, err - } - - // We'll use this map to ensure we don't send the same node - // announcement more than one time as one node may have many channel - // anns we'll need to send. - nodePubsSent := make(map[routing.Vertex]struct{}) - - chanAnns := make([]lnwire.Message, 0, len(channels)*3) - for _, channel := range channels { - // If the channel doesn't have an authentication proof, then we - // won't send it over as it may not yet be finalized, or be a - // non-advertised channel. - if channel.Info.AuthProof == nil { - continue - } - - chanAnn, edge1, edge2, err := discovery.CreateChanAnnouncement( - channel.Info.AuthProof, channel.Info, channel.Policy1, - channel.Policy2, - ) - if err != nil { - return nil, err - } - - chanAnns = append(chanAnns, chanAnn) - if edge1 != nil { - chanAnns = append(chanAnns, edge1) - - // If this edge has a validated node announcement, that - // we haven't yet sent, then we'll send that as well. - nodePub := channel.Policy1.Node.PubKeyBytes - hasNodeAnn := channel.Policy1.Node.HaveNodeAnnouncement - if _, ok := nodePubsSent[nodePub]; !ok && hasNodeAnn { - nodeAnn, err := channel.Policy1.Node.NodeAnnouncement(true) - if err != nil { - return nil, err - } - - chanAnns = append(chanAnns, nodeAnn) - nodePubsSent[nodePub] = struct{}{} - } - } - if edge2 != nil { - chanAnns = append(chanAnns, edge2) - - // If this edge has a validated node announcement, that - // we haven't yet sent, then we'll send that as well. - nodePub := channel.Policy2.Node.PubKeyBytes - hasNodeAnn := channel.Policy2.Node.HaveNodeAnnouncement - if _, ok := nodePubsSent[nodePub]; !ok && hasNodeAnn { - nodeAnn, err := channel.Policy2.Node.NodeAnnouncement(true) - if err != nil { - return nil, err - } - - chanAnns = append(chanAnns, nodeAnn) - nodePubsSent[nodePub] = struct{}{} - } - } - } - - return chanAnns, nil -} - -// FetchChanUpdates returns the latest channel update messages for the -// specified short channel ID. If no channel updates are known for the channel, -// then an empty slice will be returned. -// -// NOTE: This is part of the discovery.ChannelGraphTimeSeries interface. -func (c *chanSeries) FetchChanUpdates(chain chainhash.Hash, - shortChanID lnwire.ShortChannelID) ([]*lnwire.ChannelUpdate, error) { - - chanInfo, e1, e2, err := c.graph.FetchChannelEdgesByID( - shortChanID.ToUint64(), - ) - if err != nil { - return nil, err - } - - chanUpdates := make([]*lnwire.ChannelUpdate, 0, 2) - if e1 != nil { - chanUpdate := &lnwire.ChannelUpdate{ - ChainHash: chanInfo.ChainHash, - ShortChannelID: shortChanID, - Timestamp: uint32(e1.LastUpdate.Unix()), - Flags: e1.Flags, - TimeLockDelta: e1.TimeLockDelta, - HtlcMinimumMsat: e1.MinHTLC, - BaseFee: uint32(e1.FeeBaseMSat), - FeeRate: uint32(e1.FeeProportionalMillionths), - ExtraOpaqueData: e1.ExtraOpaqueData, - } - chanUpdate.Signature, err = lnwire.NewSigFromRawSignature(e1.SigBytes) - if err != nil { - return nil, err - } - - chanUpdates = append(chanUpdates, chanUpdate) - } - if e2 != nil { - chanUpdate := &lnwire.ChannelUpdate{ - ChainHash: chanInfo.ChainHash, - ShortChannelID: shortChanID, - Timestamp: uint32(e2.LastUpdate.Unix()), - Flags: e2.Flags, - TimeLockDelta: e2.TimeLockDelta, - HtlcMinimumMsat: e2.MinHTLC, - BaseFee: uint32(e2.FeeBaseMSat), - FeeRate: uint32(e2.FeeProportionalMillionths), - ExtraOpaqueData: e2.ExtraOpaqueData, - } - chanUpdate.Signature, err = lnwire.NewSigFromRawSignature(e2.SigBytes) - if err != nil { - return nil, err - } - - chanUpdates = append(chanUpdates, chanUpdate) - } - - return chanUpdates, nil -} - -// A compile-time assertion to ensure that chanSeries meets the -// discovery.ChannelGraphTimeSeries interface. -var _ discovery.ChannelGraphTimeSeries = (*chanSeries)(nil)