akovalenko/lnd.xprv
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

multi: partition lnwire.ChanUpdateFlag into ChannelFlags and MessageFlags

Browse Source 
In this commit:

* we partition lnwire.ChanUpdateFlag into two (ChanUpdateChanFlags and
ChanUpdateMsgFlags), from a uint16 to a pair of uint8's

* we rename the ChannelUpdate.Flags to ChannelFlags and add an
additional MessageFlags field, which will be used to indicate the
presence of the optional field HtlcMaximumMsat within the ChannelUpdate.

* we partition ChannelEdgePolicy.Flags into message and channel flags.
This change corresponds to the partitioning of the ChannelUpdate's Flags
field into MessageFlags and ChannelFlags.

Co-authored-by: Johan T. Halseth <johanth@gmail.com>
This commit is contained in:
Valentine Wallace 2019-01-12 18:59:43 +01:00 committed by Johan T. Halseth
parent 375be936ce
commit 0fd6004958
No known key found for this signature in database
GPG Key ID: 15BAADA29DA20D26
21 changed files with 176 additions and 113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
autopilot/graph.go
View File

@ -229,7 +229,8 @@ func (d *databaseChannelGraph) addRandChannel(node1, node2 *btcec.PublicKey,
MinHTLC: 1, MinHTLC: 1,
FeeBaseMSat: 10, FeeBaseMSat: 10,
FeeProportionalMillionths: 10000, FeeProportionalMillionths: 10000,
Flags: 0, MessageFlags: 0,
ChannelFlags: 0,
} }
if err := d.db.UpdateEdgePolicy(edgePolicy); err != nil { if err := d.db.UpdateEdgePolicy(edgePolicy); err != nil {
@ -243,7 +244,8 @@ func (d *databaseChannelGraph) addRandChannel(node1, node2 *btcec.PublicKey,
MinHTLC: 1, MinHTLC: 1,
FeeBaseMSat: 10, FeeBaseMSat: 10,
FeeProportionalMillionths: 10000, FeeProportionalMillionths: 10000,
Flags: 1, MessageFlags: 0,
ChannelFlags: 1,
} }
if err := d.db.UpdateEdgePolicy(edgePolicy); err != nil { if err := d.db.UpdateEdgePolicy(edgePolicy); err != nil {
return nil, nil, err return nil, nil, err

22
channeldb/graph.go
View File

@ -1677,7 +1677,7 @@ func updateEdgePolicy(edges, edgeIndex, nodes *bbolt.Bucket,
// Depending on the flags value passed above, either the first // Depending on the flags value passed above, either the first
// or second edge policy is being updated. // or second edge policy is being updated.
var fromNode, toNode []byte var fromNode, toNode []byte
if edge.Flags&lnwire.ChanUpdateDirection == 0 { if edge.ChannelFlags&lnwire.ChanUpdateDirection == 0 {
fromNode = nodeInfo[:33] fromNode = nodeInfo[:33]
toNode = nodeInfo[33:66] toNode = nodeInfo[33:66]
} else { } else {
@ -2422,9 +2422,13 @@ type ChannelEdgePolicy struct {
// was received. // was received.
LastUpdate time.Time LastUpdate time.Time
// Flags is a bitfield which signals the capabilities of the channel as // MessageFlags is a bitfield which indicates the presence of optional
// well as the directed edge this update applies to. // fields (like max_htlc) in the policy.
Flags lnwire.ChanUpdateFlag MessageFlags lnwire.ChanUpdateMsgFlags
// ChannelFlags is a bitfield which signals the capabilities of the
// channel as well as the directed edge this update applies to.
ChannelFlags lnwire.ChanUpdateChanFlags
// TimeLockDelta is the number of blocks this node will subtract from // TimeLockDelta is the number of blocks this node will subtract from
// the expiry of an incoming HTLC. This value expresses the time buffer // the expiry of an incoming HTLC. This value expresses the time buffer
@ -3186,7 +3190,10 @@ func putChanEdgePolicy(edges, nodes *bbolt.Bucket, edge *ChannelEdgePolicy,
return err return err
} }
if err := binary.Write(&b, byteOrder, edge.Flags); err != nil { if err := binary.Write(&b, byteOrder, edge.MessageFlags); err != nil {
return err
}
if err := binary.Write(&b, byteOrder, edge.ChannelFlags); err != nil {
return err return err
} }
if err := binary.Write(&b, byteOrder, edge.TimeLockDelta); err != nil { if err := binary.Write(&b, byteOrder, edge.TimeLockDelta); err != nil {
@ -3363,7 +3370,10 @@ func deserializeChanEdgePolicy(r io.Reader,
unix := int64(byteOrder.Uint64(scratch[:])) unix := int64(byteOrder.Uint64(scratch[:]))
edge.LastUpdate = time.Unix(unix, 0) edge.LastUpdate = time.Unix(unix, 0)
if err := binary.Read(r, byteOrder, &edge.Flags); err != nil { if err := binary.Read(r, byteOrder, &edge.MessageFlags); err != nil {
return nil, err
}
if err := binary.Read(r, byteOrder, &edge.ChannelFlags); err != nil {
return nil, err return nil, err
} }
if err := binary.Read(r, byteOrder, &edge.TimeLockDelta); err != nil { if err := binary.Read(r, byteOrder, &edge.TimeLockDelta); err != nil {

48
channeldb/graph_test.go
View File

@ -699,7 +699,8 @@ func TestEdgeInfoUpdates(t *testing.T) {
SigBytes: testSig.Serialize(), SigBytes: testSig.Serialize(),
ChannelID: chanID, ChannelID: chanID,
LastUpdate: time.Unix(433453, 0), LastUpdate: time.Unix(433453, 0),
Flags: 0, MessageFlags: 0,
ChannelFlags: 0,
TimeLockDelta: 99, TimeLockDelta: 99,
MinHTLC: 2342135, MinHTLC: 2342135,
FeeBaseMSat: 4352345, FeeBaseMSat: 4352345,
@ -712,7 +713,8 @@ func TestEdgeInfoUpdates(t *testing.T) {
SigBytes: testSig.Serialize(), SigBytes: testSig.Serialize(),
ChannelID: chanID, ChannelID: chanID,
LastUpdate: time.Unix(124234, 0), LastUpdate: time.Unix(124234, 0),
Flags: 1, MessageFlags: 0,
ChannelFlags: 1,
TimeLockDelta: 99, TimeLockDelta: 99,
MinHTLC: 2342135, MinHTLC: 2342135,
FeeBaseMSat: 4352345, FeeBaseMSat: 4352345,
@ -792,6 +794,8 @@ func newEdgePolicy(chanID uint64, op wire.OutPoint, db *DB,
return &ChannelEdgePolicy{ return &ChannelEdgePolicy{
ChannelID: chanID, ChannelID: chanID,
LastUpdate: time.Unix(updateTime, 0), LastUpdate: time.Unix(updateTime, 0),
MessageFlags: 0,
ChannelFlags: 0,
TimeLockDelta: uint16(prand.Int63()), TimeLockDelta: uint16(prand.Int63()),
MinHTLC: lnwire.MilliSatoshi(prand.Int63()), MinHTLC: lnwire.MilliSatoshi(prand.Int63()),
FeeBaseMSat: lnwire.MilliSatoshi(prand.Int63()), FeeBaseMSat: lnwire.MilliSatoshi(prand.Int63()),
@ -894,7 +898,7 @@ func TestGraphTraversal(t *testing.T) {
// Create and add an edge with random data that points from // Create and add an edge with random data that points from
// node1 -> node2. // node1 -> node2.
edge := randEdgePolicy(chanID, op, db) edge := randEdgePolicy(chanID, op, db)
edge.Flags = 0 edge.ChannelFlags = 0
edge.Node = secondNode edge.Node = secondNode
edge.SigBytes = testSig.Serialize() edge.SigBytes = testSig.Serialize()
if err := graph.UpdateEdgePolicy(edge); err != nil { if err := graph.UpdateEdgePolicy(edge); err != nil {
@ -904,7 +908,7 @@ func TestGraphTraversal(t *testing.T) {
// Create another random edge that points from node2 -> node1 // Create another random edge that points from node2 -> node1
// this time. // this time.
edge = randEdgePolicy(chanID, op, db) edge = randEdgePolicy(chanID, op, db)
edge.Flags = 1 edge.ChannelFlags = 1
edge.Node = firstNode edge.Node = firstNode
edge.SigBytes = testSig.Serialize() edge.SigBytes = testSig.Serialize()
if err := graph.UpdateEdgePolicy(edge); err != nil { if err := graph.UpdateEdgePolicy(edge); err != nil {
@ -1145,7 +1149,7 @@ func TestGraphPruning(t *testing.T) {
// Create and add an edge with random data that points from // Create and add an edge with random data that points from
// node_i -> node_i+1 // node_i -> node_i+1
edge := randEdgePolicy(chanID, op, db) edge := randEdgePolicy(chanID, op, db)
edge.Flags = 0 edge.ChannelFlags = 0
edge.Node = graphNodes[i] edge.Node = graphNodes[i]
edge.SigBytes = testSig.Serialize() edge.SigBytes = testSig.Serialize()
if err := graph.UpdateEdgePolicy(edge); err != nil { if err := graph.UpdateEdgePolicy(edge); err != nil {
@ -1155,7 +1159,7 @@ func TestGraphPruning(t *testing.T) {
// Create another random edge that points from node_i+1 -> // Create another random edge that points from node_i+1 ->
// node_i this time. // node_i this time.
edge = randEdgePolicy(chanID, op, db) edge = randEdgePolicy(chanID, op, db)
edge.Flags = 1 edge.ChannelFlags = 1
edge.Node = graphNodes[i] edge.Node = graphNodes[i]
edge.SigBytes = testSig.Serialize() edge.SigBytes = testSig.Serialize()
if err := graph.UpdateEdgePolicy(edge); err != nil { if err := graph.UpdateEdgePolicy(edge); err != nil {
@ -1414,7 +1418,7 @@ func TestChanUpdatesInHorizon(t *testing.T) {
edge1 := newEdgePolicy( edge1 := newEdgePolicy(
chanID.ToUint64(), op, db, edge1UpdateTime.Unix(), chanID.ToUint64(), op, db, edge1UpdateTime.Unix(),
) )
edge1.Flags = 0 edge1.ChannelFlags = 0
edge1.Node = node2 edge1.Node = node2
edge1.SigBytes = testSig.Serialize() edge1.SigBytes = testSig.Serialize()
if err := graph.UpdateEdgePolicy(edge1); err != nil { if err := graph.UpdateEdgePolicy(edge1); err != nil {
@ -1424,7 +1428,7 @@ func TestChanUpdatesInHorizon(t *testing.T) {
edge2 := newEdgePolicy( edge2 := newEdgePolicy(
chanID.ToUint64(), op, db, edge2UpdateTime.Unix(), chanID.ToUint64(), op, db, edge2UpdateTime.Unix(),
) )
edge2.Flags = 1 edge2.ChannelFlags = 1
edge2.Node = node1 edge2.Node = node1
edge2.SigBytes = testSig.Serialize() edge2.SigBytes = testSig.Serialize()
if err := graph.UpdateEdgePolicy(edge2); err != nil { if err := graph.UpdateEdgePolicy(edge2); err != nil {
@ -1915,7 +1919,7 @@ func TestFetchChanInfos(t *testing.T) {
edge1 := newEdgePolicy( edge1 := newEdgePolicy(
chanID.ToUint64(), op, db, updateTime.Unix(), chanID.ToUint64(), op, db, updateTime.Unix(),
) )
edge1.Flags = 0 edge1.ChannelFlags = 0
edge1.Node = node2 edge1.Node = node2
edge1.SigBytes = testSig.Serialize() edge1.SigBytes = testSig.Serialize()
if err := graph.UpdateEdgePolicy(edge1); err != nil { if err := graph.UpdateEdgePolicy(edge1); err != nil {
@ -1925,7 +1929,7 @@ func TestFetchChanInfos(t *testing.T) {
edge2 := newEdgePolicy( edge2 := newEdgePolicy(
chanID.ToUint64(), op, db, updateTime.Unix(), chanID.ToUint64(), op, db, updateTime.Unix(),
) )
edge2.Flags = 1 edge2.ChannelFlags = 1
edge2.Node = node1 edge2.Node = node1
edge2.SigBytes = testSig.Serialize() edge2.SigBytes = testSig.Serialize()
if err := graph.UpdateEdgePolicy(edge2); err != nil { if err := graph.UpdateEdgePolicy(edge2); err != nil {
@ -2053,7 +2057,7 @@ func TestIncompleteChannelPolicies(t *testing.T) {
edgePolicy := newEdgePolicy( edgePolicy := newEdgePolicy(
chanID.ToUint64(), op, db, updateTime.Unix(), chanID.ToUint64(), op, db, updateTime.Unix(),
) )
edgePolicy.Flags = 0 edgePolicy.ChannelFlags = 0
edgePolicy.Node = node2 edgePolicy.Node = node2
edgePolicy.SigBytes = testSig.Serialize() edgePolicy.SigBytes = testSig.Serialize()
if err := graph.UpdateEdgePolicy(edgePolicy); err != nil { if err := graph.UpdateEdgePolicy(edgePolicy); err != nil {
@ -2068,7 +2072,7 @@ func TestIncompleteChannelPolicies(t *testing.T) {
edgePolicy = newEdgePolicy( edgePolicy = newEdgePolicy(
chanID.ToUint64(), op, db, updateTime.Unix(), chanID.ToUint64(), op, db, updateTime.Unix(),
) )
edgePolicy.Flags = 1 edgePolicy.ChannelFlags = 1
edgePolicy.Node = node1 edgePolicy.Node = node1
edgePolicy.SigBytes = testSig.Serialize() edgePolicy.SigBytes = testSig.Serialize()
if err := graph.UpdateEdgePolicy(edgePolicy); err != nil { if err := graph.UpdateEdgePolicy(edgePolicy); err != nil {
@ -2125,7 +2129,7 @@ func TestChannelEdgePruningUpdateIndexDeletion(t *testing.T) {
} }
edge1 := randEdgePolicy(chanID.ToUint64(), edgeInfo.ChannelPoint, db) edge1 := randEdgePolicy(chanID.ToUint64(), edgeInfo.ChannelPoint, db)
edge1.Flags = 0 edge1.ChannelFlags = 0
edge1.Node = node1 edge1.Node = node1
edge1.SigBytes = testSig.Serialize() edge1.SigBytes = testSig.Serialize()
if err := graph.UpdateEdgePolicy(edge1); err != nil { if err := graph.UpdateEdgePolicy(edge1); err != nil {
@ -2133,7 +2137,7 @@ func TestChannelEdgePruningUpdateIndexDeletion(t *testing.T) {
} }
edge2 := randEdgePolicy(chanID.ToUint64(), edgeInfo.ChannelPoint, db) edge2 := randEdgePolicy(chanID.ToUint64(), edgeInfo.ChannelPoint, db)
edge2.Flags = 1 edge2.ChannelFlags = 1
edge2.Node = node2 edge2.Node = node2
edge2.SigBytes = testSig.Serialize() edge2.SigBytes = testSig.Serialize()
if err := graph.UpdateEdgePolicy(edge2); err != nil { if err := graph.UpdateEdgePolicy(edge2); err != nil {
@ -2190,12 +2194,12 @@ func TestChannelEdgePruningUpdateIndexDeletion(t *testing.T) {
// Now, we'll update the edge policies to ensure the old timestamps are // Now, we'll update the edge policies to ensure the old timestamps are
// removed from the update index. // removed from the update index.
edge1.Flags = 2 edge1.ChannelFlags = 2
edge1.LastUpdate = time.Now() edge1.LastUpdate = time.Now()
if err := graph.UpdateEdgePolicy(edge1); err != nil { if err := graph.UpdateEdgePolicy(edge1); err != nil {
t.Fatalf("unable to update edge: %v", err) t.Fatalf("unable to update edge: %v", err)
} }
edge2.Flags = 3 edge2.ChannelFlags = 3
edge2.LastUpdate = edge1.LastUpdate.Add(time.Hour) edge2.LastUpdate = edge1.LastUpdate.Add(time.Hour)
if err := graph.UpdateEdgePolicy(edge2); err != nil { if err := graph.UpdateEdgePolicy(edge2); err != nil {
t.Fatalf("unable to update edge: %v", err) t.Fatalf("unable to update edge: %v", err)
@ -2282,7 +2286,7 @@ func TestPruneGraphNodes(t *testing.T) {
// We'll now insert an advertised edge, but it'll only be the edge that // We'll now insert an advertised edge, but it'll only be the edge that
// points from the first to the second node. // points from the first to the second node.
edge1 := randEdgePolicy(chanID.ToUint64(), edgeInfo.ChannelPoint, db) edge1 := randEdgePolicy(chanID.ToUint64(), edgeInfo.ChannelPoint, db)
edge1.Flags = 0 edge1.ChannelFlags = 0
edge1.Node = node1 edge1.Node = node1
edge1.SigBytes = testSig.Serialize() edge1.SigBytes = testSig.Serialize()
if err := graph.UpdateEdgePolicy(edge1); err != nil { if err := graph.UpdateEdgePolicy(edge1); err != nil {
@ -2645,9 +2649,13 @@ func compareEdgePolicies(a, b *ChannelEdgePolicy) error {
return fmt.Errorf("edge LastUpdate doesn't match: expected %#v, \n "+ return fmt.Errorf("edge LastUpdate doesn't match: expected %#v, \n "+
"got %#v", a.LastUpdate, b.LastUpdate) "got %#v", a.LastUpdate, b.LastUpdate)
} }
if a.Flags != b.Flags { if a.MessageFlags != b.MessageFlags {
return fmt.Errorf("Flags doesn't match: expected %v, "+ return fmt.Errorf("MessageFlags doesn't match: expected %v, "+
"got %v", a.Flags, b.Flags) "got %v", a.MessageFlags, b.MessageFlags)
}
if a.ChannelFlags != b.ChannelFlags {
return fmt.Errorf("ChannelFlags doesn't match: expected %v, "+
"got %v", a.ChannelFlags, b.ChannelFlags)
} }
if a.TimeLockDelta != b.TimeLockDelta { if a.TimeLockDelta != b.TimeLockDelta {
return fmt.Errorf("TimeLockDelta doesn't match: expected %v, "+ return fmt.Errorf("TimeLockDelta doesn't match: expected %v, "+

6
discovery/chan_series.go
View File

@ -327,7 +327,8 @@ func (c *ChanSeries) FetchChanUpdates(chain chainhash.Hash,
ChainHash: chanInfo.ChainHash, ChainHash: chanInfo.ChainHash,
ShortChannelID: shortChanID, ShortChannelID: shortChanID,
Timestamp: uint32(e1.LastUpdate.Unix()), Timestamp: uint32(e1.LastUpdate.Unix()),
Flags: e1.Flags, MessageFlags: e1.MessageFlags,
ChannelFlags: e1.ChannelFlags,
TimeLockDelta: e1.TimeLockDelta, TimeLockDelta: e1.TimeLockDelta,
HtlcMinimumMsat: e1.MinHTLC, HtlcMinimumMsat: e1.MinHTLC,
BaseFee: uint32(e1.FeeBaseMSat), BaseFee: uint32(e1.FeeBaseMSat),
@ -346,7 +347,8 @@ func (c *ChanSeries) FetchChanUpdates(chain chainhash.Hash,
ChainHash: chanInfo.ChainHash, ChainHash: chanInfo.ChainHash,
ShortChannelID: shortChanID, ShortChannelID: shortChanID,
Timestamp: uint32(e2.LastUpdate.Unix()), Timestamp: uint32(e2.LastUpdate.Unix()),
Flags: e2.Flags, MessageFlags: e2.MessageFlags,
ChannelFlags: e2.ChannelFlags,
TimeLockDelta: e2.TimeLockDelta, TimeLockDelta: e2.TimeLockDelta,
HtlcMinimumMsat: e2.MinHTLC, HtlcMinimumMsat: e2.MinHTLC,
BaseFee: uint32(e2.FeeBaseMSat), BaseFee: uint32(e2.FeeBaseMSat),

26
discovery/gossiper.go
View File

@ -560,7 +560,7 @@ func (d *AuthenticatedGossiper) ProcessLocalAnnouncement(msg lnwire.Message,
} }
// channelUpdateID is a unique identifier for ChannelUpdate messages, as // channelUpdateID is a unique identifier for ChannelUpdate messages, as
// channel updates can be identified by the (ShortChannelID, Flags) // channel updates can be identified by the (ShortChannelID, ChannelFlags)
// tuple. // tuple.
type channelUpdateID struct { type channelUpdateID struct {
// channelID represents the set of data which is needed to // channelID represents the set of data which is needed to
@ -570,7 +570,7 @@ type channelUpdateID struct {
// Flags least-significant bit must be set to 0 if the creating node // Flags least-significant bit must be set to 0 if the creating node
// corresponds to the first node in the previously sent channel // corresponds to the first node in the previously sent channel
// announcement and 1 otherwise. // announcement and 1 otherwise.
flags lnwire.ChanUpdateFlag flags lnwire.ChanUpdateChanFlags
} }
// msgWithSenders is a wrapper struct around a message, and the set of peers // msgWithSenders is a wrapper struct around a message, and the set of peers
@ -669,13 +669,13 @@ func (d *deDupedAnnouncements) addMsg(message networkMsg) {
mws.senders[sender] = struct{}{} mws.senders[sender] = struct{}{}
d.channelAnnouncements[deDupKey] = mws d.channelAnnouncements[deDupKey] = mws
// Channel updates are identified by the (short channel id, flags) // Channel updates are identified by the (short channel id,
// tuple. // channelflags) tuple.
case *lnwire.ChannelUpdate: case *lnwire.ChannelUpdate:
sender := routing.NewVertex(message.source) sender := routing.NewVertex(message.source)
deDupKey := channelUpdateID{ deDupKey := channelUpdateID{
msg.ShortChannelID, msg.ShortChannelID,
msg.Flags, msg.ChannelFlags,
} }
oldTimestamp := uint32(0) oldTimestamp := uint32(0)
@ -1911,7 +1911,7 @@ func (d *AuthenticatedGossiper) processNetworkAnnouncement(
// announcement for this edge. // announcement for this edge.
timestamp := time.Unix(int64(msg.Timestamp), 0) timestamp := time.Unix(int64(msg.Timestamp), 0)
if d.cfg.Router.IsStaleEdgePolicy( if d.cfg.Router.IsStaleEdgePolicy(
msg.ShortChannelID, timestamp, msg.Flags, msg.ShortChannelID, timestamp, msg.ChannelFlags,
) { ) {
nMsg.err <- nil nMsg.err <- nil
@ -1986,9 +1986,9 @@ func (d *AuthenticatedGossiper) processNetworkAnnouncement(
// edge is being updated. // edge is being updated.
var pubKey *btcec.PublicKey var pubKey *btcec.PublicKey
switch { switch {
case msg.Flags&lnwire.ChanUpdateDirection == 0: case msg.ChannelFlags&lnwire.ChanUpdateDirection == 0:
pubKey, _ = chanInfo.NodeKey1() pubKey, _ = chanInfo.NodeKey1()
case msg.Flags&lnwire.ChanUpdateDirection == 1: case msg.ChannelFlags&lnwire.ChanUpdateDirection == 1:
pubKey, _ = chanInfo.NodeKey2() pubKey, _ = chanInfo.NodeKey2()
} }
@ -2009,7 +2009,8 @@ func (d *AuthenticatedGossiper) processNetworkAnnouncement(
SigBytes: msg.Signature.ToSignatureBytes(), SigBytes: msg.Signature.ToSignatureBytes(),
ChannelID: shortChanID, ChannelID: shortChanID,
LastUpdate: timestamp, LastUpdate: timestamp,
Flags: msg.Flags, MessageFlags: msg.MessageFlags,
ChannelFlags: msg.ChannelFlags,
TimeLockDelta: msg.TimeLockDelta, TimeLockDelta: msg.TimeLockDelta,
MinHTLC: msg.HtlcMinimumMsat, MinHTLC: msg.HtlcMinimumMsat,
FeeBaseMSat: lnwire.MilliSatoshi(msg.BaseFee), FeeBaseMSat: lnwire.MilliSatoshi(msg.BaseFee),
@ -2041,9 +2042,9 @@ func (d *AuthenticatedGossiper) processNetworkAnnouncement(
// Get our peer's public key. // Get our peer's public key.
var remotePub *btcec.PublicKey var remotePub *btcec.PublicKey
switch { switch {
case msg.Flags&lnwire.ChanUpdateDirection == 0: case msg.ChannelFlags&lnwire.ChanUpdateDirection == 0:
remotePub, _ = chanInfo.NodeKey2() remotePub, _ = chanInfo.NodeKey2()
case msg.Flags&lnwire.ChanUpdateDirection == 1: case msg.ChannelFlags&lnwire.ChanUpdateDirection == 1:
remotePub, _ = chanInfo.NodeKey1() remotePub, _ = chanInfo.NodeKey1()
} }
@ -2517,7 +2518,8 @@ func (d *AuthenticatedGossiper) updateChannel(info *channeldb.ChannelEdgeInfo,
ChainHash: info.ChainHash, ChainHash: info.ChainHash,
ShortChannelID: lnwire.NewShortChanIDFromInt(edge.ChannelID), ShortChannelID: lnwire.NewShortChanIDFromInt(edge.ChannelID),
Timestamp: uint32(timestamp), Timestamp: uint32(timestamp),
Flags: edge.Flags, MessageFlags: edge.MessageFlags,
ChannelFlags: edge.ChannelFlags,
TimeLockDelta: edge.TimeLockDelta, TimeLockDelta: edge.TimeLockDelta,
HtlcMinimumMsat: edge.MinHTLC, HtlcMinimumMsat: edge.MinHTLC,
BaseFee: uint32(edge.FeeBaseMSat), BaseFee: uint32(edge.FeeBaseMSat),

14
discovery/gossiper_test.go
View File

@ -258,7 +258,7 @@ func (r *mockGraphSource) IsKnownEdge(chanID lnwire.ShortChannelID) bool {
// IsStaleEdgePolicy returns true if the graph source has a channel edge for // IsStaleEdgePolicy returns true if the graph source has a channel edge for
// the passed channel ID (and flags) that have a more recent timestamp. // the passed channel ID (and flags) that have a more recent timestamp.
func (r *mockGraphSource) IsStaleEdgePolicy(chanID lnwire.ShortChannelID, func (r *mockGraphSource) IsStaleEdgePolicy(chanID lnwire.ShortChannelID,
timestamp time.Time, flags lnwire.ChanUpdateFlag) bool { timestamp time.Time, flags lnwire.ChanUpdateChanFlags) bool {
edges, ok := r.edges[chanID.ToUint64()] edges, ok := r.edges[chanID.ToUint64()]
if !ok { if !ok {
@ -267,10 +267,10 @@ func (r *mockGraphSource) IsStaleEdgePolicy(chanID lnwire.ShortChannelID,
switch { switch {
case len(edges) >= 1 && edges[0].Flags == flags: case len(edges) >= 1 && edges[0].ChannelFlags == flags:
return !edges[0].LastUpdate.Before(timestamp) return !edges[0].LastUpdate.Before(timestamp)
case len(edges) >= 2 && edges[1].Flags == flags: case len(edges) >= 2 && edges[1].ChannelFlags == flags:
return !edges[1].LastUpdate.Before(timestamp) return !edges[1].LastUpdate.Before(timestamp)
default: default:
@ -440,7 +440,8 @@ func createNodeAnnouncement(priv *btcec.PrivateKey,
return a, nil return a, nil
} }
func createUpdateAnnouncement(blockHeight uint32, flags lnwire.ChanUpdateFlag, func createUpdateAnnouncement(blockHeight uint32,
flags lnwire.ChanUpdateChanFlags,
nodeKey *btcec.PrivateKey, timestamp uint32, nodeKey *btcec.PrivateKey, timestamp uint32,
extraBytes ...[]byte) (*lnwire.ChannelUpdate, error) { extraBytes ...[]byte) (*lnwire.ChannelUpdate, error) {
@ -451,8 +452,9 @@ func createUpdateAnnouncement(blockHeight uint32, flags lnwire.ChanUpdateFlag,
BlockHeight: blockHeight, BlockHeight: blockHeight,
}, },
Timestamp: timestamp, Timestamp: timestamp,
MessageFlags: 0,
ChannelFlags: flags,
TimeLockDelta: uint16(prand.Int63()), TimeLockDelta: uint16(prand.Int63()),
Flags: flags,
HtlcMinimumMsat: lnwire.MilliSatoshi(prand.Int63()), HtlcMinimumMsat: lnwire.MilliSatoshi(prand.Int63()),
FeeRate: uint32(prand.Int31()), FeeRate: uint32(prand.Int31()),
BaseFee: uint32(prand.Int31()), BaseFee: uint32(prand.Int31()),
@ -2028,7 +2030,7 @@ func TestDeDuplicatedAnnouncements(t *testing.T) {
assertChannelUpdate := func(channelUpdate *lnwire.ChannelUpdate) { assertChannelUpdate := func(channelUpdate *lnwire.ChannelUpdate) {
channelKey := channelUpdateID{ channelKey := channelUpdateID{
ua3.ShortChannelID, ua3.ShortChannelID,
ua3.Flags, ua3.ChannelFlags,
} }
mws, ok := announcements.channelUpdates[channelKey] mws, ok := announcements.channelUpdates[channelKey]

6
discovery/utils.go
View File

@ -72,7 +72,8 @@ func CreateChanAnnouncement(chanProof *channeldb.ChannelAuthProof,
ChainHash: chanInfo.ChainHash, ChainHash: chanInfo.ChainHash,
ShortChannelID: chanID, ShortChannelID: chanID,
Timestamp: uint32(e1.LastUpdate.Unix()), Timestamp: uint32(e1.LastUpdate.Unix()),
Flags: e1.Flags, MessageFlags: e1.MessageFlags,
ChannelFlags: e1.ChannelFlags,
TimeLockDelta: e1.TimeLockDelta, TimeLockDelta: e1.TimeLockDelta,
HtlcMinimumMsat: e1.MinHTLC, HtlcMinimumMsat: e1.MinHTLC,
BaseFee: uint32(e1.FeeBaseMSat), BaseFee: uint32(e1.FeeBaseMSat),
@ -89,7 +90,8 @@ func CreateChanAnnouncement(chanProof *channeldb.ChannelAuthProof,
ChainHash: chanInfo.ChainHash, ChainHash: chanInfo.ChainHash,
ShortChannelID: chanID, ShortChannelID: chanID,
Timestamp: uint32(e2.LastUpdate.Unix()), Timestamp: uint32(e2.LastUpdate.Unix()),
Flags: e2.Flags, MessageFlags: e2.MessageFlags,
ChannelFlags: e2.ChannelFlags,
TimeLockDelta: e2.TimeLockDelta, TimeLockDelta: e2.TimeLockDelta,
HtlcMinimumMsat: e2.MinHTLC, HtlcMinimumMsat: e2.MinHTLC,
BaseFee: uint32(e2.FeeBaseMSat), BaseFee: uint32(e2.FeeBaseMSat),

5
fundingmanager.go
View File

@ -2468,7 +2468,7 @@ func (f *fundingManager) newChanAnnouncement(localPubKey, remotePubKey,
// being updated within the ChannelUpdateAnnouncement announcement // being updated within the ChannelUpdateAnnouncement announcement
// below. A value of zero means it's the edge of the "first" node and 1 // below. A value of zero means it's the edge of the "first" node and 1
// being the other node. // being the other node.
var chanFlags lnwire.ChanUpdateFlag var chanFlags lnwire.ChanUpdateChanFlags
// The lexicographical ordering of the two identity public keys of the // The lexicographical ordering of the two identity public keys of the
// nodes indicates which of the nodes is "first". If our serialized // nodes indicates which of the nodes is "first". If our serialized
@ -2502,7 +2502,8 @@ func (f *fundingManager) newChanAnnouncement(localPubKey, remotePubKey,
ShortChannelID: shortChanID, ShortChannelID: shortChanID,
ChainHash: chainHash, ChainHash: chainHash,
Timestamp: uint32(time.Now().Unix()), Timestamp: uint32(time.Now().Unix()),
Flags: chanFlags, MessageFlags: 0,
ChannelFlags: chanFlags,
TimeLockDelta: uint16(f.cfg.DefaultRoutingPolicy.TimeLockDelta), TimeLockDelta: uint16(f.cfg.DefaultRoutingPolicy.TimeLockDelta),
// We use the HtlcMinimumMsat that the remote party required us // We use the HtlcMinimumMsat that the remote party required us

30
lnwire/channel_update.go
View File

@ -8,16 +8,20 @@ import (
"github.com/btcsuite/btcd/chaincfg/chainhash" "github.com/btcsuite/btcd/chaincfg/chainhash"
) )
// ChanUpdateFlag is a bitfield that signals various options concerning a // ChanUpdateMsgFlags is a bitfield that signals whether optional fields are
// present in the ChannelUpdate.
type ChanUpdateMsgFlags uint8
// ChanUpdateChanFlags is a bitfield that signals various options concerning a
// particular channel edge. Each bit is to be examined in order to determine // particular channel edge. Each bit is to be examined in order to determine
// how the ChannelUpdate message is to be interpreted. // how the ChannelUpdate message is to be interpreted.
type ChanUpdateFlag uint16 type ChanUpdateChanFlags uint8
const ( const (
// ChanUpdateDirection indicates the direction of a channel update. If // ChanUpdateDirection indicates the direction of a channel update. If
// this bit is set to 0 if Node1 (the node with the "smaller" Node ID) // this bit is set to 0 if Node1 (the node with the "smaller" Node ID)
// is updating the channel, and to 1 otherwise. // is updating the channel, and to 1 otherwise.
ChanUpdateDirection ChanUpdateFlag = 1 << iota ChanUpdateDirection ChanUpdateChanFlags = 1 << iota
// ChanUpdateDisabled is a bit that indicates if the channel edge // ChanUpdateDisabled is a bit that indicates if the channel edge
// selected by the ChanUpdateDirection bit is to be treated as being // selected by the ChanUpdateDirection bit is to be treated as being
@ -48,13 +52,18 @@ type ChannelUpdate struct {
// the last-received. // the last-received.
Timestamp uint32 Timestamp uint32
// Flags is a bitfield that describes additional meta-data concerning // MessageFlags is a bitfield that describes whether optional fields
// how the update is to be interpreted. Currently, the // are present in this update. Currently, the least-significant bit
// must be set to 1 if the optional field MaxHtlc is present.
MessageFlags ChanUpdateMsgFlags
// ChannelFlags is a bitfield that describes additional meta-data
// concerning how the update is to be interpreted. Currently, the
// least-significant bit must be set to 0 if the creating node // least-significant bit must be set to 0 if the creating node
// corresponds to the first node in the previously sent channel // corresponds to the first node in the previously sent channel
// announcement and 1 otherwise. If the second bit is set, then the // announcement and 1 otherwise. If the second bit is set, then the
// channel is set to be disabled. // channel is set to be disabled.
Flags ChanUpdateFlag ChannelFlags ChanUpdateChanFlags
// TimeLockDelta is the minimum number of blocks this node requires to // TimeLockDelta is the minimum number of blocks this node requires to
// be added to the expiry of HTLCs. This is a security parameter // be added to the expiry of HTLCs. This is a security parameter
@ -98,7 +107,8 @@ func (a *ChannelUpdate) Decode(r io.Reader, pver uint32) error {
a.ChainHash[:], a.ChainHash[:],
&a.ShortChannelID, &a.ShortChannelID,
&a.Timestamp, &a.Timestamp,
&a.Flags, &a.MessageFlags,
&a.ChannelFlags,
&a.TimeLockDelta, &a.TimeLockDelta,
&a.HtlcMinimumMsat, &a.HtlcMinimumMsat,
&a.BaseFee, &a.BaseFee,
@ -133,7 +143,8 @@ func (a *ChannelUpdate) Encode(w io.Writer, pver uint32) error {
a.ChainHash[:], a.ChainHash[:],
a.ShortChannelID, a.ShortChannelID,
a.Timestamp, a.Timestamp,
a.Flags, a.MessageFlags,
a.ChannelFlags,
a.TimeLockDelta, a.TimeLockDelta,
a.HtlcMinimumMsat, a.HtlcMinimumMsat,
a.BaseFee, a.BaseFee,
@ -168,7 +179,8 @@ func (a *ChannelUpdate) DataToSign() ([]byte, error) {
a.ChainHash[:], a.ChainHash[:],
a.ShortChannelID, a.ShortChannelID,
a.Timestamp, a.Timestamp,
a.Flags, a.MessageFlags,
a.ChannelFlags,
a.TimeLockDelta, a.TimeLockDelta,
a.HtlcMinimumMsat, a.HtlcMinimumMsat,
a.BaseFee, a.BaseFee,

26
lnwire/lnwire.go
View File

@ -105,9 +105,15 @@ func WriteElement(w io.Writer, element interface{}) error {
if _, err := w.Write(b[:]); err != nil { if _, err := w.Write(b[:]); err != nil {
return err return err
} }
case ChanUpdateFlag: case ChanUpdateMsgFlags:
var b [2]byte var b [1]byte
binary.BigEndian.PutUint16(b[:], uint16(e)) b[0] = uint8(e)
if _, err := w.Write(b[:]); err != nil {
return err
}
case ChanUpdateChanFlags:
var b [1]byte
b[0] = uint8(e)
if _, err := w.Write(b[:]); err != nil { if _, err := w.Write(b[:]); err != nil {
return err return err
} }
@ -470,12 +476,18 @@ func ReadElement(r io.Reader, element interface{}) error {
return err return err
} }
*e = binary.BigEndian.Uint16(b[:]) *e = binary.BigEndian.Uint16(b[:])
case *ChanUpdateFlag: case *ChanUpdateMsgFlags:
var b [2]byte var b [1]uint8
if _, err := io.ReadFull(r, b[:]); err != nil { if _, err := r.Read(b[:]); err != nil {
return err return err
} }
*e = ChanUpdateFlag(binary.BigEndian.Uint16(b[:])) *e = ChanUpdateMsgFlags(b[0])
case *ChanUpdateChanFlags:
var b [1]uint8
if _, err := r.Read(b[:]); err != nil {
return err
}
*e = ChanUpdateChanFlags(b[0])
case *ErrorCode: case *ErrorCode:
var b [2]byte var b [2]byte
if _, err := io.ReadFull(r, b[:]); err != nil { if _, err := io.ReadFull(r, b[:]); err != nil {

3
lnwire/lnwire_test.go
View File

@ -608,7 +608,8 @@ func TestLightningWireProtocol(t *testing.T) {
req := ChannelUpdate{ req := ChannelUpdate{
ShortChannelID: NewShortChanIDFromInt(uint64(r.Int63())), ShortChannelID: NewShortChanIDFromInt(uint64(r.Int63())),
Timestamp: uint32(r.Int31()), Timestamp: uint32(r.Int31()),
Flags: ChanUpdateFlag(r.Int31()), MessageFlags: ChanUpdateMsgFlags(r.Int31()),
ChannelFlags: ChanUpdateChanFlags(r.Int31()),
TimeLockDelta: uint16(r.Int31()), TimeLockDelta: uint16(r.Int31()),
HtlcMinimumMsat: MilliSatoshi(r.Int63()), HtlcMinimumMsat: MilliSatoshi(r.Int63()),
BaseFee: uint32(r.Int31()), BaseFee: uint32(r.Int31()),

3
lnwire/onion_error_test.go
View File

@ -20,7 +20,8 @@ var (
Signature: sig, Signature: sig,
ShortChannelID: NewShortChanIDFromInt(1), ShortChannelID: NewShortChanIDFromInt(1),
Timestamp: 1, Timestamp: 1,
Flags: 1, MessageFlags: 0,
ChannelFlags: 1,
} }
) )

8
peer.go
View File

@ -1235,10 +1235,10 @@ func messageSummary(msg lnwire.Message) string {
msg.ChainHash, msg.ShortChannelID.ToUint64()) msg.ChainHash, msg.ShortChannelID.ToUint64())
case *lnwire.ChannelUpdate: case *lnwire.ChannelUpdate:
return fmt.Sprintf("chain_hash=%v, short_chan_id=%v, flag=%v, "+ return fmt.Sprintf("chain_hash=%v, short_chan_id=%v, "+
"update_time=%v", msg.ChainHash, "mflags=%v, cflags=%v, update_time=%v", msg.ChainHash,
msg.ShortChannelID.ToUint64(), msg.Flags, msg.ShortChannelID.ToUint64(), msg.MessageFlags,
time.Unix(int64(msg.Timestamp), 0)) msg.ChannelFlags, time.Unix(int64(msg.Timestamp), 0))
case *lnwire.NodeAnnouncement: case *lnwire.NodeAnnouncement:
return fmt.Sprintf("node=%x, update_time=%v", return fmt.Sprintf("node=%x, update_time=%v",

4
routing/notifications.go
View File

@ -339,7 +339,7 @@ func addToTopologyChange(graph *channeldb.ChannelGraph, update *TopologyChange,
// the second node. // the second node.
sourceNode := edgeInfo.NodeKey1 sourceNode := edgeInfo.NodeKey1
connectingNode := edgeInfo.NodeKey2 connectingNode := edgeInfo.NodeKey2
if m.Flags&lnwire.ChanUpdateDirection == 1 { if m.ChannelFlags&lnwire.ChanUpdateDirection == 1 {
sourceNode = edgeInfo.NodeKey2 sourceNode = edgeInfo.NodeKey2
connectingNode = edgeInfo.NodeKey1 connectingNode = edgeInfo.NodeKey1
} }
@ -363,7 +363,7 @@ func addToTopologyChange(graph *channeldb.ChannelGraph, update *TopologyChange,
FeeRate: m.FeeProportionalMillionths, FeeRate: m.FeeProportionalMillionths,
AdvertisingNode: aNode, AdvertisingNode: aNode,
ConnectingNode: cNode, ConnectingNode: cNode,
Disabled: m.Flags&lnwire.ChanUpdateDisabled != 0, Disabled: m.ChannelFlags&lnwire.ChanUpdateDisabled != 0,
} }
edgeUpdate.AdvertisingNode.Curve = nil edgeUpdate.AdvertisingNode.Curve = nil
edgeUpdate.ConnectingNode.Curve = nil edgeUpdate.ConnectingNode.Curve = nil

4
routing/notifications_test.go
View File

@ -402,9 +402,9 @@ func TestEdgeUpdateNotification(t *testing.T) {
// Create random policy edges that are stemmed to the channel id // Create random policy edges that are stemmed to the channel id
// created above. // created above.
edge1 := randEdgePolicy(chanID, node1) edge1 := randEdgePolicy(chanID, node1)
edge1.Flags = 0 edge1.ChannelFlags = 0
edge2 := randEdgePolicy(chanID, node2) edge2 := randEdgePolicy(chanID, node2)
edge2.Flags = 1 edge2.ChannelFlags = 1
if err := ctx.router.UpdateEdge(edge1); err != nil { if err := ctx.router.UpdateEdge(edge1); err != nil {
t.Fatalf("unable to add edge update: %v", err) t.Fatalf("unable to add edge update: %v", err)

2
routing/pathfind.go
View File

@ -562,7 +562,7 @@ func findPath(g *graphParams, r *restrictParams,
// TODO(halseth): also ignore disable flags for non-local // TODO(halseth): also ignore disable flags for non-local
// channels if bandwidth hint is set? // channels if bandwidth hint is set?
isSourceChan := fromVertex == sourceVertex isSourceChan := fromVertex == sourceVertex
edgeFlags := lnwire.ChanUpdateFlag(edge.Flags) edgeFlags := edge.ChannelFlags
isDisabled := edgeFlags&lnwire.ChanUpdateDisabled != 0 isDisabled := edgeFlags&lnwire.ChanUpdateDisabled != 0
if !isSourceChan && isDisabled { if !isSourceChan && isDisabled {

19
routing/pathfind_test.go
View File

@ -271,7 +271,8 @@ func parseTestGraph(path string) (*testGraphInstance, error) {
edgePolicy := &channeldb.ChannelEdgePolicy{ edgePolicy := &channeldb.ChannelEdgePolicy{
SigBytes: testSig.Serialize(), SigBytes: testSig.Serialize(),
Flags: lnwire.ChanUpdateFlag(edge.Flags), MessageFlags: lnwire.ChanUpdateMsgFlags(edge.Flags >> 8),
ChannelFlags: lnwire.ChanUpdateChanFlags(edge.Flags),
ChannelID: edge.ChannelID, ChannelID: edge.ChannelID,
LastUpdate: testTime, LastUpdate: testTime,
TimeLockDelta: edge.Expiry, TimeLockDelta: edge.Expiry,
@ -487,7 +488,8 @@ func createTestGraphFromChannels(testChannels []*testChannel) (*testGraphInstanc
edgePolicy := &channeldb.ChannelEdgePolicy{ edgePolicy := &channeldb.ChannelEdgePolicy{
SigBytes: testSig.Serialize(), SigBytes: testSig.Serialize(),
Flags: lnwire.ChanUpdateFlag(0), MessageFlags: 0,
ChannelFlags: 0,
ChannelID: channelID, ChannelID: channelID,
LastUpdate: testTime, LastUpdate: testTime,
TimeLockDelta: testChannel.Node1.Expiry, TimeLockDelta: testChannel.Node1.Expiry,
@ -501,7 +503,8 @@ func createTestGraphFromChannels(testChannels []*testChannel) (*testGraphInstanc
edgePolicy = &channeldb.ChannelEdgePolicy{ edgePolicy = &channeldb.ChannelEdgePolicy{
SigBytes: testSig.Serialize(), SigBytes: testSig.Serialize(),
Flags: lnwire.ChanUpdateFlag(lnwire.ChanUpdateDirection), MessageFlags: 0,
ChannelFlags: lnwire.ChanUpdateDirection,
ChannelID: channelID, ChannelID: channelID,
LastUpdate: testTime, LastUpdate: testTime,
TimeLockDelta: testChannel.Node2.Expiry, TimeLockDelta: testChannel.Node2.Expiry,
@ -1476,11 +1479,11 @@ func TestRouteFailDisabledEdge(t *testing.T) {
if err != nil { if err != nil {
t.Fatalf("unable to fetch edge: %v", err) t.Fatalf("unable to fetch edge: %v", err)
} }
e1.Flags |= lnwire.ChanUpdateDisabled e1.ChannelFlags |= lnwire.ChanUpdateDisabled
if err := graph.graph.UpdateEdgePolicy(e1); err != nil { if err := graph.graph.UpdateEdgePolicy(e1); err != nil {
t.Fatalf("unable to update edge: %v", err) t.Fatalf("unable to update edge: %v", err)
} }
e2.Flags |= lnwire.ChanUpdateDisabled e2.ChannelFlags |= lnwire.ChanUpdateDisabled
if err := graph.graph.UpdateEdgePolicy(e2); err != nil { if err := graph.graph.UpdateEdgePolicy(e2); err != nil {
t.Fatalf("unable to update edge: %v", err) t.Fatalf("unable to update edge: %v", err)
} }
@ -1507,7 +1510,7 @@ func TestRouteFailDisabledEdge(t *testing.T) {
if err != nil { if err != nil {
t.Fatalf("unable to fetch edge: %v", err) t.Fatalf("unable to fetch edge: %v", err)
} }
e.Flags |= lnwire.ChanUpdateDisabled e.ChannelFlags |= lnwire.ChanUpdateDisabled
if err := graph.graph.UpdateEdgePolicy(e); err != nil { if err := graph.graph.UpdateEdgePolicy(e); err != nil {
t.Fatalf("unable to update edge: %v", err) t.Fatalf("unable to update edge: %v", err)
} }
@ -1627,11 +1630,11 @@ func TestPathSourceEdgesBandwidth(t *testing.T) {
if err != nil { if err != nil {
t.Fatalf("unable to fetch edge: %v", err) t.Fatalf("unable to fetch edge: %v", err)
} }
e1.Flags |= lnwire.ChanUpdateDisabled e1.ChannelFlags |= lnwire.ChanUpdateDisabled
if err := graph.graph.UpdateEdgePolicy(e1); err != nil { if err := graph.graph.UpdateEdgePolicy(e1); err != nil {
t.Fatalf("unable to update edge: %v", err) t.Fatalf("unable to update edge: %v", err)
} }
e2.Flags |= lnwire.ChanUpdateDisabled e2.ChannelFlags |= lnwire.ChanUpdateDisabled
if err := graph.graph.UpdateEdgePolicy(e2); err != nil { if err := graph.graph.UpdateEdgePolicy(e2); err != nil {
t.Fatalf("unable to update edge: %v", err) t.Fatalf("unable to update edge: %v", err)
} }

24
routing/router.go
View File

@ -84,7 +84,7 @@ type ChannelGraphSource interface {
// edge for the passed channel ID (and flags) that have a more recent // edge for the passed channel ID (and flags) that have a more recent
// timestamp. // timestamp.
IsStaleEdgePolicy(chanID lnwire.ShortChannelID, timestamp time.Time, IsStaleEdgePolicy(chanID lnwire.ShortChannelID, timestamp time.Time,
flags lnwire.ChanUpdateFlag) bool flags lnwire.ChanUpdateChanFlags) bool
// ForAllOutgoingChannels is used to iterate over all channels // ForAllOutgoingChannels is used to iterate over all channels
// emanating from the "source" node which is the center of the // emanating from the "source" node which is the center of the
@ -243,7 +243,7 @@ func newEdgeLocatorByPubkeys(channelID uint64, fromNode, toNode *Vertex) *edgeLo
func newEdgeLocator(edge *channeldb.ChannelEdgePolicy) *edgeLocator { func newEdgeLocator(edge *channeldb.ChannelEdgePolicy) *edgeLocator {
return &edgeLocator{ return &edgeLocator{
channelID: edge.ChannelID, channelID: edge.ChannelID,
direction: uint8(edge.Flags & lnwire.ChanUpdateDirection), direction: uint8(edge.ChannelFlags & lnwire.ChanUpdateDirection),
} }
} }
@ -1149,25 +1149,26 @@ func (r *ChannelRouter) processUpdate(msg interface{}) error {
// A flag set of 0 indicates this is an announcement for the // A flag set of 0 indicates this is an announcement for the
// "first" node in the channel. // "first" node in the channel.
case msg.Flags&lnwire.ChanUpdateDirection == 0: case msg.ChannelFlags&lnwire.ChanUpdateDirection == 0:
// Ignore outdated message. // Ignore outdated message.
if !edge1Timestamp.Before(msg.LastUpdate) { if !edge1Timestamp.Before(msg.LastUpdate) {
return newErrf(ErrOutdated, "Ignoring "+ return newErrf(ErrOutdated, "Ignoring "+
"outdated update (flags=%v) for known "+ "outdated update (flags=%v|%v) for "+
"chan_id=%v", msg.Flags, msg.ChannelID) "known chan_id=%v", msg.MessageFlags,
msg.ChannelFlags, msg.ChannelID)
} }
// Similarly, a flag set of 1 indicates this is an announcement // Similarly, a flag set of 1 indicates this is an announcement
// for the "second" node in the channel. // for the "second" node in the channel.
case msg.Flags&lnwire.ChanUpdateDirection == 1: case msg.ChannelFlags&lnwire.ChanUpdateDirection == 1:
// Ignore outdated message. // Ignore outdated message.
if !edge2Timestamp.Before(msg.LastUpdate) { if !edge2Timestamp.Before(msg.LastUpdate) {
return newErrf(ErrOutdated, "Ignoring "+ return newErrf(ErrOutdated, "Ignoring "+
"outdated update (flags=%v) for known "+ "outdated update (flags=%v|%v) for "+
"chan_id=%v", msg.Flags, msg.ChannelID) "known chan_id=%v", msg.MessageFlags,
msg.ChannelFlags, msg.ChannelID)
} }
} }
@ -2068,7 +2069,8 @@ func (r *ChannelRouter) applyChannelUpdate(msg *lnwire.ChannelUpdate,
SigBytes: msg.Signature.ToSignatureBytes(), SigBytes: msg.Signature.ToSignatureBytes(),
ChannelID: msg.ShortChannelID.ToUint64(), ChannelID: msg.ShortChannelID.ToUint64(),
LastUpdate: time.Unix(int64(msg.Timestamp), 0), LastUpdate: time.Unix(int64(msg.Timestamp), 0),
Flags: msg.Flags, MessageFlags: msg.MessageFlags,
ChannelFlags: msg.ChannelFlags,
TimeLockDelta: msg.TimeLockDelta, TimeLockDelta: msg.TimeLockDelta,
MinHTLC: msg.HtlcMinimumMsat, MinHTLC: msg.HtlcMinimumMsat,
FeeBaseMSat: lnwire.MilliSatoshi(msg.BaseFee), FeeBaseMSat: lnwire.MilliSatoshi(msg.BaseFee),
@ -2270,7 +2272,7 @@ func (r *ChannelRouter) IsKnownEdge(chanID lnwire.ShortChannelID) bool {
// //
// NOTE: This method is part of the ChannelGraphSource interface. // NOTE: This method is part of the ChannelGraphSource interface.
func (r *ChannelRouter) IsStaleEdgePolicy(chanID lnwire.ShortChannelID, func (r *ChannelRouter) IsStaleEdgePolicy(chanID lnwire.ShortChannelID,
timestamp time.Time, flags lnwire.ChanUpdateFlag) bool { timestamp time.Time, flags lnwire.ChanUpdateChanFlags) bool {
edge1Timestamp, edge2Timestamp, exists, err := r.cfg.Graph.HasChannelEdge( edge1Timestamp, edge2Timestamp, exists, err := r.cfg.Graph.HasChannelEdge(
chanID.ToUint64(), chanID.ToUint64(),

18
routing/router_test.go
View File

@ -550,7 +550,8 @@ func TestSendPaymentErrorRepeatedFeeInsufficient(t *testing.T) {
errChanUpdate := lnwire.ChannelUpdate{ errChanUpdate := lnwire.ChannelUpdate{
ShortChannelID: lnwire.NewShortChanIDFromInt(chanID), ShortChannelID: lnwire.NewShortChanIDFromInt(chanID),
Timestamp: uint32(edgeUpateToFail.LastUpdate.Unix()), Timestamp: uint32(edgeUpateToFail.LastUpdate.Unix()),
Flags: edgeUpateToFail.Flags, MessageFlags: edgeUpateToFail.MessageFlags,
ChannelFlags: edgeUpateToFail.ChannelFlags,
TimeLockDelta: edgeUpateToFail.TimeLockDelta, TimeLockDelta: edgeUpateToFail.TimeLockDelta,
HtlcMinimumMsat: edgeUpateToFail.MinHTLC, HtlcMinimumMsat: edgeUpateToFail.MinHTLC,
BaseFee: uint32(edgeUpateToFail.FeeBaseMSat), BaseFee: uint32(edgeUpateToFail.FeeBaseMSat),
@ -656,7 +657,8 @@ func TestSendPaymentErrorNonFinalTimeLockErrors(t *testing.T) {
errChanUpdate := lnwire.ChannelUpdate{ errChanUpdate := lnwire.ChannelUpdate{
ShortChannelID: lnwire.NewShortChanIDFromInt(chanID), ShortChannelID: lnwire.NewShortChanIDFromInt(chanID),
Timestamp: uint32(edgeUpateToFail.LastUpdate.Unix()), Timestamp: uint32(edgeUpateToFail.LastUpdate.Unix()),
Flags: edgeUpateToFail.Flags, MessageFlags: edgeUpateToFail.MessageFlags,
ChannelFlags: edgeUpateToFail.ChannelFlags,
TimeLockDelta: edgeUpateToFail.TimeLockDelta, TimeLockDelta: edgeUpateToFail.TimeLockDelta,
HtlcMinimumMsat: edgeUpateToFail.MinHTLC, HtlcMinimumMsat: edgeUpateToFail.MinHTLC,
BaseFee: uint32(edgeUpateToFail.FeeBaseMSat), BaseFee: uint32(edgeUpateToFail.FeeBaseMSat),
@ -1098,7 +1100,7 @@ func TestAddEdgeUnknownVertexes(t *testing.T) {
FeeBaseMSat: 10, FeeBaseMSat: 10,
FeeProportionalMillionths: 10000, FeeProportionalMillionths: 10000,
} }
edgePolicy.Flags = 0 edgePolicy.ChannelFlags = 0
if err := ctx.router.UpdateEdge(edgePolicy); err != nil { if err := ctx.router.UpdateEdge(edgePolicy); err != nil {
t.Fatalf("unable to update edge policy: %v", err) t.Fatalf("unable to update edge policy: %v", err)
@ -1114,7 +1116,7 @@ func TestAddEdgeUnknownVertexes(t *testing.T) {
FeeBaseMSat: 10, FeeBaseMSat: 10,
FeeProportionalMillionths: 10000, FeeProportionalMillionths: 10000,
} }
edgePolicy.Flags = 1 edgePolicy.ChannelFlags = 1
if err := ctx.router.UpdateEdge(edgePolicy); err != nil { if err := ctx.router.UpdateEdge(edgePolicy); err != nil {
t.Fatalf("unable to update edge policy: %v", err) t.Fatalf("unable to update edge policy: %v", err)
@ -1194,7 +1196,7 @@ func TestAddEdgeUnknownVertexes(t *testing.T) {
FeeBaseMSat: 10, FeeBaseMSat: 10,
FeeProportionalMillionths: 10000, FeeProportionalMillionths: 10000,
} }
edgePolicy.Flags = 0 edgePolicy.ChannelFlags = 0
if err := ctx.router.UpdateEdge(edgePolicy); err != nil { if err := ctx.router.UpdateEdge(edgePolicy); err != nil {
t.Fatalf("unable to update edge policy: %v", err) t.Fatalf("unable to update edge policy: %v", err)
@ -1209,7 +1211,7 @@ func TestAddEdgeUnknownVertexes(t *testing.T) {
FeeBaseMSat: 10, FeeBaseMSat: 10,
FeeProportionalMillionths: 10000, FeeProportionalMillionths: 10000,
} }
edgePolicy.Flags = 1 edgePolicy.ChannelFlags = 1
if err := ctx.router.UpdateEdge(edgePolicy); err != nil { if err := ctx.router.UpdateEdge(edgePolicy); err != nil {
t.Fatalf("unable to update edge policy: %v", err) t.Fatalf("unable to update edge policy: %v", err)
@ -2099,7 +2101,7 @@ func TestIsStaleEdgePolicy(t *testing.T) {
FeeBaseMSat: 10, FeeBaseMSat: 10,
FeeProportionalMillionths: 10000, FeeProportionalMillionths: 10000,
} }
edgePolicy.Flags = 0 edgePolicy.ChannelFlags = 0
if err := ctx.router.UpdateEdge(edgePolicy); err != nil { if err := ctx.router.UpdateEdge(edgePolicy); err != nil {
t.Fatalf("unable to update edge policy: %v", err) t.Fatalf("unable to update edge policy: %v", err)
} }
@ -2113,7 +2115,7 @@ func TestIsStaleEdgePolicy(t *testing.T) {
FeeBaseMSat: 10, FeeBaseMSat: 10,
FeeProportionalMillionths: 10000, FeeProportionalMillionths: 10000,
} }
edgePolicy.Flags = 1 edgePolicy.ChannelFlags = 1
if err := ctx.router.UpdateEdge(edgePolicy); err != nil { if err := ctx.router.UpdateEdge(edgePolicy); err != nil {
t.Fatalf("unable to update edge policy: %v", err) t.Fatalf("unable to update edge policy: %v", err)
} }

4
rpcserver.go
View File

@ -3769,7 +3769,7 @@ func marshalDbEdge(edgeInfo *channeldb.ChannelEdgeInfo,
MinHtlc: int64(c1.MinHTLC), MinHtlc: int64(c1.MinHTLC),
FeeBaseMsat: int64(c1.FeeBaseMSat), FeeBaseMsat: int64(c1.FeeBaseMSat),
FeeRateMilliMsat: int64(c1.FeeProportionalMillionths), FeeRateMilliMsat: int64(c1.FeeProportionalMillionths),
Disabled: c1.Flags&lnwire.ChanUpdateDisabled != 0, Disabled: c1.ChannelFlags&lnwire.ChanUpdateDisabled != 0,
} }
} }
@ -3779,7 +3779,7 @@ func marshalDbEdge(edgeInfo *channeldb.ChannelEdgeInfo,
MinHtlc: int64(c2.MinHTLC), MinHtlc: int64(c2.MinHTLC),
FeeBaseMsat: int64(c2.FeeBaseMSat), FeeBaseMsat: int64(c2.FeeBaseMSat),
FeeRateMilliMsat: int64(c2.FeeProportionalMillionths), FeeRateMilliMsat: int64(c2.FeeProportionalMillionths),
Disabled: c2.Flags&lnwire.ChanUpdateDisabled != 0, Disabled: c2.ChannelFlags&lnwire.ChanUpdateDisabled != 0,
} }
} }

11
server.go
View File

@ -2978,10 +2978,10 @@ func (s *server) announceChanStatus(op wire.OutPoint, disabled bool) error {
if disabled { if disabled {
// Set the bit responsible for marking a channel as disabled. // Set the bit responsible for marking a channel as disabled.
chanUpdate.Flags |= lnwire.ChanUpdateDisabled chanUpdate.ChannelFlags |= lnwire.ChanUpdateDisabled
} else { } else {
// Clear the bit responsible for marking a channel as disabled. // Clear the bit responsible for marking a channel as disabled.
chanUpdate.Flags &= ^lnwire.ChanUpdateDisabled chanUpdate.ChannelFlags &= ^lnwire.ChanUpdateDisabled
} }
// We must now update the message's timestamp and generate a new // We must now update the message's timestamp and generate a new
@ -3066,9 +3066,9 @@ func extractChannelUpdate(ownerPubKey []byte,
owner := func(edge *channeldb.ChannelEdgePolicy) []byte { owner := func(edge *channeldb.ChannelEdgePolicy) []byte {
var pubKey *btcec.PublicKey var pubKey *btcec.PublicKey
switch { switch {
case edge.Flags&lnwire.ChanUpdateDirection == 0: case edge.ChannelFlags&lnwire.ChanUpdateDirection == 0:
pubKey, _ = info.NodeKey1() pubKey, _ = info.NodeKey1()
case edge.Flags&lnwire.ChanUpdateDirection == 1: case edge.ChannelFlags&lnwire.ChanUpdateDirection == 1:
pubKey, _ = info.NodeKey2() pubKey, _ = info.NodeKey2()
} }
@ -3100,7 +3100,8 @@ func createChannelUpdate(info *channeldb.ChannelEdgeInfo,
ChainHash: info.ChainHash, ChainHash: info.ChainHash,
ShortChannelID: lnwire.NewShortChanIDFromInt(policy.ChannelID), ShortChannelID: lnwire.NewShortChanIDFromInt(policy.ChannelID),
Timestamp: uint32(policy.LastUpdate.Unix()), Timestamp: uint32(policy.LastUpdate.Unix()),
Flags: policy.Flags, MessageFlags: policy.MessageFlags,
ChannelFlags: policy.ChannelFlags,
TimeLockDelta: policy.TimeLockDelta, TimeLockDelta: policy.TimeLockDelta,
HtlcMinimumMsat: policy.MinHTLC, HtlcMinimumMsat: policy.MinHTLC,
BaseFee: uint32(policy.FeeBaseMSat), BaseFee: uint32(policy.FeeBaseMSat),