12879602034

Committed 21 Jan 2025 03:26AM UTC coverage: 49.413% (-9.3%) from 58.72%

Build # 12879602034

Build Type

Pull #9430

github

Committed by

Roasbeef

Commit Message

lnwallet: add new NoopAdd payDesc entry type

In this commit, we add a new NoopAdd payDesc entry type. This type is
meant to be used primarily by taproot overlay channels. When we go to
settle this HTLC, rather than credit the settler for the funds, we just
give the funds back to the sender. This results in an add that when
settled, doesn't affect the balance in the channel.

This new HTLC type is intended to be used alongside a push amt, to
ensure the remote party has a non-dust balance from the start. With that
in place, then this new add type can be used for special overlay HTLCs.

Pull Request Pull Request #9430: lnwallet: add new NoopAdd payDesc entry type

Run Details

23 of 36 new or added lines in 2 files covered. (63.89%)

26915 existing lines in 431 files now uncovered.

100600 of 203591 relevant lines covered (49.41%)

1.54 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

86.49

/graph/db/reject_cache.go

package graphdb

// rejectFlags is a compact representation of various metadata stored by the
// reject cache about a particular channel.
type rejectFlags uint8

const (
        // rejectFlagExists is a flag indicating whether the channel exists,
        // i.e. the channel is open and has a recent channel update. If this
        // flag is not set, the channel is either a zombie or unknown.
        rejectFlagExists rejectFlags = 1 << iota

        // rejectFlagZombie is a flag indicating whether the channel is a
        // zombie, i.e. the channel is open but has no recent channel updates.
        rejectFlagZombie
)

// packRejectFlags computes the rejectFlags corresponding to the passed boolean
// values indicating whether the edge exists or is a zombie.
func packRejectFlags(exists, isZombie bool) rejectFlags {
        var flags rejectFlags
        if exists {
                flags |= rejectFlagExists
        }
        if isZombie {
                flags |= rejectFlagZombie
        }

        return flags
}

// unpack returns the booleans packed into the rejectFlags. The first indicates
// if the edge exists in our graph, the second indicates if the edge is a
// zombie.
func (f rejectFlags) unpack() (bool, bool) {
        return f&rejectFlagExists == rejectFlagExists,
                f&rejectFlagZombie == rejectFlagZombie
}

// rejectCacheEntry caches frequently accessed information about a channel,
// including the timestamps of its latest edge policies and whether or not the
// channel exists in the graph.
type rejectCacheEntry struct {
        upd1Time int64
        upd2Time int64
        flags    rejectFlags
}

// rejectCache is an in-memory cache used to improve the performance of
// HasChannelEdge. It caches information about the whether or channel exists, as
// well as the most recent timestamps for each policy (if they exists).
type rejectCache struct {
        n     int
        edges map[uint64]rejectCacheEntry
}

// newRejectCache creates a new rejectCache with maximum capacity of n entries.
func newRejectCache(n int) *rejectCache {
        return &rejectCache{
                n:     n,
                edges: make(map[uint64]rejectCacheEntry, n),
        }
}

// get returns the entry from the cache for chanid, if it exists.
func (c *rejectCache) get(chanid uint64) (rejectCacheEntry, bool) {
        entry, ok := c.edges[chanid]
        return entry, ok
}

// insert adds the entry to the reject cache. If an entry for chanid already
// exists, it will be replaced with the new entry. If the entry doesn't exists,
// it will be inserted to the cache, performing a random eviction if the cache
// is at capacity.
func (c *rejectCache) insert(chanid uint64, entry rejectCacheEntry) {
        // If entry exists, replace it.
        if _, ok := c.edges[chanid]; ok {
                c.edges[chanid] = entry
                return
        }

        // Otherwise, evict an entry at random and insert.
        if len(c.edges) == c.n {
                for id := range c.edges {
                        delete(c.edges, id)
                        break
                }
        }
        c.edges[chanid] = entry
}

// remove deletes an entry for chanid from the cache, if it exists.
func (c *rejectCache) remove(chanid uint64) {
        delete(c.edges, chanid)
}

1	package graphdb
2
3	// rejectFlags is a compact representation of various metadata stored by the
4	// reject cache about a particular channel.
5	type rejectFlags uint8
6
7	const (
8	// rejectFlagExists is a flag indicating whether the channel exists,
9	// i.e. the channel is open and has a recent channel update. If this
10	// flag is not set, the channel is either a zombie or unknown.
11	rejectFlagExists rejectFlags = 1 << iota
12
13	// rejectFlagZombie is a flag indicating whether the channel is a
14	// zombie, i.e. the channel is open but has no recent channel updates.
15	rejectFlagZombie
16	)
17
18	// packRejectFlags computes the rejectFlags corresponding to the passed boolean
19	// values indicating whether the edge exists or is a zombie.
20	func packRejectFlags(exists, isZombie bool) rejectFlags {	3✔
21	var flags rejectFlags	3✔
22	if exists {	6✔
23	flags \|= rejectFlagExists	3✔
24	}	3✔
25	if isZombie {	3✔
UNCOV 26	flags \|= rejectFlagZombie	×
UNCOV 27	}	×
28
29	return flags	3✔
30	}
31
32	// unpack returns the booleans packed into the rejectFlags. The first indicates
33	// if the edge exists in our graph, the second indicates if the edge is a
34	// zombie.
35	func (f rejectFlags) unpack() (bool, bool) {	3✔
36	return f&rejectFlagExists == rejectFlagExists,	3✔
37	f&rejectFlagZombie == rejectFlagZombie	3✔
38	}	3✔
39
40	// rejectCacheEntry caches frequently accessed information about a channel,
41	// including the timestamps of its latest edge policies and whether or not the
42	// channel exists in the graph.
43	type rejectCacheEntry struct {
44	upd1Time int64
45	upd2Time int64
46	flags rejectFlags
47	}
48
49	// rejectCache is an in-memory cache used to improve the performance of
50	// HasChannelEdge. It caches information about the whether or channel exists, as
51	// well as the most recent timestamps for each policy (if they exists).
52	type rejectCache struct {
53	n int
54	edges map[uint64]rejectCacheEntry
55	}
56
57	// newRejectCache creates a new rejectCache with maximum capacity of n entries.
58	func newRejectCache(n int) *rejectCache {	3✔
59	return &rejectCache{	3✔
60	n: n,	3✔
61	edges: make(map[uint64]rejectCacheEntry, n),	3✔
62	}	3✔
63	}	3✔
64
65	// get returns the entry from the cache for chanid, if it exists.
66	func (c *rejectCache) get(chanid uint64) (rejectCacheEntry, bool) {	3✔
67	entry, ok := c.edges[chanid]	3✔
68	return entry, ok	3✔
69	}	3✔
70
71	// insert adds the entry to the reject cache. If an entry for chanid already
72	// exists, it will be replaced with the new entry. If the entry doesn't exists,
73	// it will be inserted to the cache, performing a random eviction if the cache
74	// is at capacity.
75	func (c *rejectCache) insert(chanid uint64, entry rejectCacheEntry) {	3✔
76	// If entry exists, replace it.	3✔
77	if _, ok := c.edges[chanid]; ok {	6✔
78	c.edges[chanid] = entry	3✔
79	return	3✔
80	}	3✔
81
82	// Otherwise, evict an entry at random and insert.
83	if len(c.edges) == c.n {	3✔
UNCOV 84	for id := range c.edges {	×
UNCOV 85	delete(c.edges, id)	×
UNCOV 86	break	×
87	}
88	}
89	c.edges[chanid] = entry	3✔
90	}
91
92	// remove deletes an entry for chanid from the cache, if it exists.
93	func (c *rejectCache) remove(chanid uint64) {	3✔
94	delete(c.edges, chanid)	3✔
95	}	3✔

lightningnetwork / lnd / 12879602034

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous