13211764208

Committed 08 Feb 2025 03:08AM UTC coverage: 49.288% (-9.5%) from 58.815%

Build # 13211764208

Build Type

Pull #9489

github

Committed by

calvinrzachman

Commit Message

itest: verify switchrpc server enforces send then track

We prevent the rpc server from allowing onion dispatches for
attempt IDs which have already been tracked by rpc clients.

This helps protect the client from leaking a duplicate onion
attempt. NOTE: This is not the only method for solving this
issue! The issue could be addressed via careful client side
programming which accounts for the uncertainty and async
nature of dispatching onions to a remote process via RPC.
This would require some lnd ChannelRouter changes for how
we intend to use these RPCs though.

Pull Request Pull Request #9489: multi: add BuildOnion, SendOnion, and TrackOnion RPCs

Run Details

474 of 990 new or added lines in 11 files covered. (47.88%)

27321 existing lines in 435 files now uncovered.

101192 of 205306 relevant lines covered (49.29%)

1.54 hits per line

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

69.71

/htlcswitch/htlcnotifier.go

package htlcswitch

import (
        "fmt"
        "strings"
        "sync"
        "time"

        "github.com/lightningnetwork/lnd/channeldb"
        "github.com/lightningnetwork/lnd/graph/db/models"
        "github.com/lightningnetwork/lnd/htlcswitch/hop"
        "github.com/lightningnetwork/lnd/lntypes"
        "github.com/lightningnetwork/lnd/lnwire"
        "github.com/lightningnetwork/lnd/subscribe"
)

// HtlcNotifier notifies clients of htlc forwards, failures and settles for
// htlcs that the switch handles. It takes subscriptions for its events and
// notifies them when htlc events occur. These are served on a best-effort
// basis; events are not persisted, delivery is not guaranteed (in the event
// of a crash in the switch, forward events may be lost) and some events may
// be replayed upon restart. Events consumed from this package should be
// de-duplicated by the htlc's unique combination of incoming+outgoing circuit
// and not relied upon for critical operations.
//
// The htlc notifier sends the following kinds of events:
// Forwarding Event:
// - Represents a htlc which is forwarded onward from our node.
// - Present for htlc forwards through our node and local sends.
//
// Link Failure Event:
//   - Indicates that a htlc has failed on our incoming or outgoing link,
//     with an incoming boolean which indicates where the failure occurred.
//   - Incoming link failures are present for failed attempts to pay one of
//     our invoices (insufficient amount or mpp timeout, for example) and for
//     forwards that we cannot decode to forward onwards.
//   - Outgoing link failures are present for forwards or local payments that
//     do not meet our outgoing link's policy (insufficient fees, for example)
//     and when we fail to forward the payment on (insufficient outgoing
//     capacity, or an unknown outgoing link).
//
// Forwarding Failure Event:
//   - Forwarding failures indicate that a htlc we forwarded has failed at
//     another node down the route.
//   - Present for local sends and htlc forwards which fail after they left
//     our node.
//
// Settle event:
//   - Settle events are present when a htlc which we added is settled through
//     the release of a preimage.
//   - Present for local receives, and successful local sends or forwards.
//
// Each htlc is identified by its incoming and outgoing circuit key. Htlcs,
// and their subsequent settles or fails, can be identified by the combination
// of incoming and outgoing circuits. Note that receives to our node will
// have a zero outgoing circuit key because the htlc terminates at our
// node, and sends from our node will have a zero incoming circuit key because
// the send originates at our node.
type HtlcNotifier struct {
        started sync.Once
        stopped sync.Once

        // now returns the current time, it is set in the htlcnotifier to allow
        // for timestamp mocking in tests.
        now func() time.Time

        ntfnServer *subscribe.Server
}

// NewHtlcNotifier creates a new HtlcNotifier which gets htlc forwarded,
// failed and settled events from links our node has established with peers
// and sends notifications to subscribing clients.
func NewHtlcNotifier(now func() time.Time) *HtlcNotifier {
        return &HtlcNotifier{
                now:        now,
                ntfnServer: subscribe.NewServer(),
        }
}

// Start starts the HtlcNotifier and all goroutines it needs to consume
// events and provide subscriptions to clients.
func (h *HtlcNotifier) Start() error {
        var err error
        h.started.Do(func() {
                log.Info("HtlcNotifier starting")
                err = h.ntfnServer.Start()
        })
        return err
}

// Stop signals the notifier for a graceful shutdown.
func (h *HtlcNotifier) Stop() error {
        var err error
        h.stopped.Do(func() {
                log.Info("HtlcNotifier shutting down...")
                defer log.Debug("HtlcNotifier shutdown complete")

                if err = h.ntfnServer.Stop(); err != nil {
                        log.Warnf("error stopping htlc notifier: %v", err)
                }
        })
        return err
}

// SubscribeHtlcEvents returns a subscribe.Client that will receive updates
// any time the server is made aware of a new event.
func (h *HtlcNotifier) SubscribeHtlcEvents() (*subscribe.Client, error) {
        return h.ntfnServer.Subscribe()
}

// HtlcKey uniquely identifies the htlc.
type HtlcKey struct {
        // IncomingCircuit is the channel an htlc id of the incoming htlc.
        IncomingCircuit models.CircuitKey

        // OutgoingCircuit is the channel and htlc id of the outgoing htlc.
        OutgoingCircuit models.CircuitKey
}

// String returns a string representation of a htlc key.
func (k HtlcKey) String() string {
        switch {
        case k.IncomingCircuit.ChanID == hop.Source:
                return k.OutgoingCircuit.String()

        case k.OutgoingCircuit.ChanID == hop.Exit:
                return k.IncomingCircuit.String()

        default:
                return fmt.Sprintf("%v -> %v", k.IncomingCircuit,
                        k.OutgoingCircuit)
        }
}

// HtlcInfo provides the details of a htlc that our node has processed. For
// forwards, incoming and outgoing values are set, whereas sends and receives
// will only have outgoing or incoming details set.
type HtlcInfo struct {
        // IncomingTimelock is the time lock of the htlc on our incoming
        // channel.
        IncomingTimeLock uint32

        // OutgoingTimelock is the time lock the htlc on our outgoing channel.
        OutgoingTimeLock uint32

        // IncomingAmt is the amount of the htlc on our incoming channel.
        IncomingAmt lnwire.MilliSatoshi

        // OutgoingAmt is the amount of the htlc on our outgoing channel.
        OutgoingAmt lnwire.MilliSatoshi
}

// String returns a string representation of a htlc.
func (h HtlcInfo) String() string {
        var details []string

        // If the incoming information is not zero, as is the case for a send,
        // we include the incoming amount and timelock.
        if h.IncomingAmt != 0 || h.IncomingTimeLock != 0 {
                str := fmt.Sprintf("incoming amount: %v, "+
                        "incoming timelock: %v", h.IncomingAmt,
                        h.IncomingTimeLock)

                details = append(details, str)
        }

        // If the outgoing information is not zero, as is the case for a
        // receive, we include the outgoing amount and timelock.
        if h.OutgoingAmt != 0 || h.OutgoingTimeLock != 0 {
                str := fmt.Sprintf("outgoing amount: %v, "+
                        "outgoing timelock: %v", h.OutgoingAmt,
                        h.OutgoingTimeLock)

                details = append(details, str)
        }

        return strings.Join(details, ", ")
}

// HtlcEventType represents the type of event that a htlc was part of.
type HtlcEventType int

const (
        // HtlcEventTypeSend represents a htlc that was part of a send from
        // our node.
        HtlcEventTypeSend HtlcEventType = iota

        // HtlcEventTypeReceive represents a htlc that was part of a receive
        // to our node.
        HtlcEventTypeReceive

        // HtlcEventTypeForward represents a htlc that was forwarded through
        // our node.
        HtlcEventTypeForward
)

// String returns a string representation of a htlc event type.
func (h HtlcEventType) String() string {
        switch h {
        case HtlcEventTypeSend:
                return "send"

        case HtlcEventTypeReceive:
                return "receive"

        case HtlcEventTypeForward:
                return "forward"

        default:
                return "unknown"
        }
}

// ForwardingEvent represents a htlc that was forwarded onwards from our node.
// Sends which originate from our node will report forward events with zero
// incoming circuits in their htlc key.
type ForwardingEvent struct {
        // HtlcKey uniquely identifies the htlc, and can be used to match the
        // forwarding event with subsequent settle/fail events.
        HtlcKey

        // HtlcInfo contains details about the htlc.
        HtlcInfo

        // HtlcEventType classifies the event as part of a local send or
        // receive, or as part of a forward.
        HtlcEventType

        // Timestamp is the time when this htlc was forwarded.
        Timestamp time.Time
}

// LinkFailEvent describes a htlc that failed on our incoming or outgoing
// link. The incoming bool is true for failures on incoming links, and false
// for failures on outgoing links. The failure reason is provided by a lnwire
// failure message which is enriched with a failure detail in the cases where
// the wire failure message does not contain full information about the
// failure.
type LinkFailEvent struct {
        // HtlcKey uniquely identifies the htlc.
        HtlcKey

        // HtlcInfo contains details about the htlc.
        HtlcInfo

        // HtlcEventType classifies the event as part of a local send or
        // receive, or as part of a forward.
        HtlcEventType

        // LinkError is the reason that we failed the htlc.
        LinkError *LinkError

        // Incoming is true if the htlc was failed on an incoming link.
        // If it failed on the outgoing link, it is false.
        Incoming bool

        // Timestamp is the time when the link failure occurred.
        Timestamp time.Time
}

// ForwardingFailEvent represents a htlc failure which occurred down the line
// after we forwarded a htlc onwards. An error is not included in this event
// because errors returned down the route are encrypted. HtlcInfo is not
// reliably available for forwarding failures, so it is omitted. These events
// should be matched with their corresponding forward event to obtain this
// information.
type ForwardingFailEvent struct {
        // HtlcKey uniquely identifies the htlc, and can be used to match the
        // htlc with its corresponding forwarding event.
        HtlcKey

        // HtlcEventType classifies the event as part of a local send or
        // receive, or as part of a forward.
        HtlcEventType

        // Timestamp is the time when the forwarding failure was received.
        Timestamp time.Time
}

// SettleEvent represents a htlc that was settled. HtlcInfo is not reliably
// available for forwarding failures, so it is omitted. These events should
// be matched with corresponding forward events or invoices (for receives)
// to obtain additional information about the htlc.
type SettleEvent struct {
        // HtlcKey uniquely identifies the htlc, and can be used to match
        // forwards with their corresponding forwarding event.
        HtlcKey

        // Preimage that was released for settling the htlc.
        Preimage lntypes.Preimage

        // HtlcEventType classifies the event as part of a local send or
        // receive, or as part of a forward.
        HtlcEventType

        // Timestamp is the time when this htlc was settled.
        Timestamp time.Time
}

type FinalHtlcEvent struct {
        CircuitKey

        Settled bool

        // Offchain is indicating whether the htlc was resolved off-chain.
        Offchain bool

        // Timestamp is the time when this htlc was settled.
        Timestamp time.Time
}

// NotifyForwardingEvent notifies the HtlcNotifier than a htlc has been
// forwarded.
//
// Note this is part of the htlcNotifier interface.
func (h *HtlcNotifier) NotifyForwardingEvent(key HtlcKey, info HtlcInfo,
        eventType HtlcEventType) {

        event := &ForwardingEvent{
                HtlcKey:       key,
                HtlcInfo:      info,
                HtlcEventType: eventType,
                Timestamp:     h.now(),
        }

        log.Tracef("Notifying forward event: %v over %v, %v", eventType, key,
                info)

        if err := h.ntfnServer.SendUpdate(event); err != nil {
                log.Warnf("Unable to send forwarding event: %v", err)
        }
}

// NotifyLinkFailEvent notifies that a htlc has failed on our incoming
// or outgoing link.
//
// Note this is part of the htlcNotifier interface.
func (h *HtlcNotifier) NotifyLinkFailEvent(key HtlcKey, info HtlcInfo,
        eventType HtlcEventType, linkErr *LinkError, incoming bool) {

        event := &LinkFailEvent{
                HtlcKey:       key,
                HtlcInfo:      info,
                HtlcEventType: eventType,
                LinkError:     linkErr,
                Incoming:      incoming,
                Timestamp:     h.now(),
        }

        log.Tracef("Notifying link failure event: %v over %v, %v", eventType,
                key, info)

        if err := h.ntfnServer.SendUpdate(event); err != nil {
                log.Warnf("Unable to send link fail event: %v", err)
        }
}

// NotifyForwardingFailEvent notifies the HtlcNotifier that a htlc we
// forwarded has failed down the line.
//
// Note this is part of the htlcNotifier interface.
func (h *HtlcNotifier) NotifyForwardingFailEvent(key HtlcKey,
        eventType HtlcEventType) {

        event := &ForwardingFailEvent{
                HtlcKey:       key,
                HtlcEventType: eventType,
                Timestamp:     h.now(),
        }

        log.Tracef("Notifying forwarding failure event: %v over %v", eventType,
                key)

        if err := h.ntfnServer.SendUpdate(event); err != nil {
                log.Warnf("Unable to send forwarding fail event: %v", err)
        }
}

// NotifySettleEvent notifies the HtlcNotifier that a htlc that we committed
// to as part of a forward or a receive to our node has been settled.
//
// Note this is part of the htlcNotifier interface.
func (h *HtlcNotifier) NotifySettleEvent(key HtlcKey,
        preimage lntypes.Preimage, eventType HtlcEventType) {

        event := &SettleEvent{
                HtlcKey:       key,
                Preimage:      preimage,
                HtlcEventType: eventType,
                Timestamp:     h.now(),
        }

        log.Tracef("Notifying settle event: %v over %v", eventType, key)

        if err := h.ntfnServer.SendUpdate(event); err != nil {
                log.Warnf("Unable to send settle event: %v", err)
        }
}

// NotifyFinalHtlcEvent notifies the HtlcNotifier that the final outcome for an
// htlc has been determined.
//
// Note this is part of the htlcNotifier interface.
func (h *HtlcNotifier) NotifyFinalHtlcEvent(key models.CircuitKey,
        info channeldb.FinalHtlcInfo) {

        event := &FinalHtlcEvent{
                CircuitKey: key,
                Settled:    info.Settled,
                Offchain:   info.Offchain,
                Timestamp:  h.now(),
        }

        log.Tracef("Notifying final settle event: %v", key)

        if err := h.ntfnServer.SendUpdate(event); err != nil {
                log.Warnf("Unable to send settle event: %v", err)
        }
}

// newHtlc key returns a htlc key for the packet provided. If the packet
// has a zero incoming channel ID, the packet is for one of our own sends,
// which has the payment id stashed in the incoming htlc id. If this is the
// case, we replace the incoming htlc id with zero so that the notifier
// consistently reports zero circuit keys for events that terminate or
// originate at our node.
func newHtlcKey(pkt *htlcPacket) HtlcKey {
        htlcKey := HtlcKey{
                IncomingCircuit: models.CircuitKey{
                        ChanID: pkt.incomingChanID,
                        HtlcID: pkt.incomingHTLCID,
                },
                OutgoingCircuit: CircuitKey{
                        ChanID: pkt.outgoingChanID,
                        HtlcID: pkt.outgoingHTLCID,
                },
        }

        // If the packet has a zero incoming channel ID, it is a send that was
        // initiated at our node. If this is the case, our internal pid is in
        // the incoming htlc ID, so we overwrite it with 0 for notification
        // purposes.
        if pkt.incomingChanID == hop.Source {
                htlcKey.IncomingCircuit.HtlcID = 0
        }

        return htlcKey
}

// newHtlcInfo returns HtlcInfo for the packet provided.
func newHtlcInfo(pkt *htlcPacket) HtlcInfo {
        return HtlcInfo{
                IncomingTimeLock: pkt.incomingTimeout,
                OutgoingTimeLock: pkt.outgoingTimeout,
                IncomingAmt:      pkt.incomingAmount,
                OutgoingAmt:      pkt.amount,
        }
}

// getEventType returns the htlc type based on the fields set in the htlc
// packet. Sends that originate at our node have the source (zero) incoming
// channel ID. Receives to our node have the exit (zero) outgoing channel ID
// and forwards have both fields set.
func getEventType(pkt *htlcPacket) HtlcEventType {
        switch {
        case pkt.incomingChanID == hop.Source:
                return HtlcEventTypeSend

        case pkt.outgoingChanID == hop.Exit:
                return HtlcEventTypeReceive

        default:
                return HtlcEventTypeForward
        }
}

1	package htlcswitch
2
3	import (
4	"fmt"
5	"strings"
6	"sync"
7	"time"
8
9	"github.com/lightningnetwork/lnd/channeldb"
10	"github.com/lightningnetwork/lnd/graph/db/models"
11	"github.com/lightningnetwork/lnd/htlcswitch/hop"
12	"github.com/lightningnetwork/lnd/lntypes"
13	"github.com/lightningnetwork/lnd/lnwire"
14	"github.com/lightningnetwork/lnd/subscribe"
15	)
16
17	// HtlcNotifier notifies clients of htlc forwards, failures and settles for
18	// htlcs that the switch handles. It takes subscriptions for its events and
19	// notifies them when htlc events occur. These are served on a best-effort
20	// basis; events are not persisted, delivery is not guaranteed (in the event
21	// of a crash in the switch, forward events may be lost) and some events may
22	// be replayed upon restart. Events consumed from this package should be
23	// de-duplicated by the htlc's unique combination of incoming+outgoing circuit
24	// and not relied upon for critical operations.
25	//
26	// The htlc notifier sends the following kinds of events:
27	// Forwarding Event:
28	// - Represents a htlc which is forwarded onward from our node.
29	// - Present for htlc forwards through our node and local sends.
30	//
31	// Link Failure Event:
32	// - Indicates that a htlc has failed on our incoming or outgoing link,
33	// with an incoming boolean which indicates where the failure occurred.
34	// - Incoming link failures are present for failed attempts to pay one of
35	// our invoices (insufficient amount or mpp timeout, for example) and for
36	// forwards that we cannot decode to forward onwards.
37	// - Outgoing link failures are present for forwards or local payments that
38	// do not meet our outgoing link's policy (insufficient fees, for example)
39	// and when we fail to forward the payment on (insufficient outgoing
40	// capacity, or an unknown outgoing link).
41	//
42	// Forwarding Failure Event:
43	// - Forwarding failures indicate that a htlc we forwarded has failed at
44	// another node down the route.
45	// - Present for local sends and htlc forwards which fail after they left
46	// our node.
47	//
48	// Settle event:
49	// - Settle events are present when a htlc which we added is settled through
50	// the release of a preimage.
51	// - Present for local receives, and successful local sends or forwards.
52	//
53	// Each htlc is identified by its incoming and outgoing circuit key. Htlcs,
54	// and their subsequent settles or fails, can be identified by the combination
55	// of incoming and outgoing circuits. Note that receives to our node will
56	// have a zero outgoing circuit key because the htlc terminates at our
57	// node, and sends from our node will have a zero incoming circuit key because
58	// the send originates at our node.
59	type HtlcNotifier struct {
60	started sync.Once
61	stopped sync.Once
62
63	// now returns the current time, it is set in the htlcnotifier to allow
64	// for timestamp mocking in tests.
65	now func() time.Time
66
67	ntfnServer *subscribe.Server
68	}
69
70	// NewHtlcNotifier creates a new HtlcNotifier which gets htlc forwarded,
71	// failed and settled events from links our node has established with peers
72	// and sends notifications to subscribing clients.
73	func NewHtlcNotifier(now func() time.Time) *HtlcNotifier {	3✔
74	return &HtlcNotifier{	3✔
75	now: now,	3✔
76	ntfnServer: subscribe.NewServer(),	3✔
77	}	3✔
78	}	3✔
79
80	// Start starts the HtlcNotifier and all goroutines it needs to consume
81	// events and provide subscriptions to clients.
82	func (h *HtlcNotifier) Start() error {	3✔
83	var err error	3✔
84	h.started.Do(func() {	6✔
85	log.Info("HtlcNotifier starting")	3✔
86	err = h.ntfnServer.Start()	3✔
87	})	3✔
88	return err	3✔
89	}
90
91	// Stop signals the notifier for a graceful shutdown.
92	func (h *HtlcNotifier) Stop() error {	3✔
93	var err error	3✔
94	h.stopped.Do(func() {	6✔
95	log.Info("HtlcNotifier shutting down...")	3✔
96	defer log.Debug("HtlcNotifier shutdown complete")	3✔
97		3✔
98	if err = h.ntfnServer.Stop(); err != nil {	3✔
99	log.Warnf("error stopping htlc notifier: %v", err)	×
100	}	×
101	})
102	return err	3✔
103	}
104
105	// SubscribeHtlcEvents returns a subscribe.Client that will receive updates
106	// any time the server is made aware of a new event.
107	func (h HtlcNotifier) SubscribeHtlcEvents() (subscribe.Client, error) {	3✔
108	return h.ntfnServer.Subscribe()	3✔
109	}	3✔
110
111	// HtlcKey uniquely identifies the htlc.
112	type HtlcKey struct {
113	// IncomingCircuit is the channel an htlc id of the incoming htlc.
114	IncomingCircuit models.CircuitKey
115
116	// OutgoingCircuit is the channel and htlc id of the outgoing htlc.
117	OutgoingCircuit models.CircuitKey
118	}
119
120	// String returns a string representation of a htlc key.
121	func (k HtlcKey) String() string {	×
122	switch {	×
123	case k.IncomingCircuit.ChanID == hop.Source:	×
124	return k.OutgoingCircuit.String()	×
125
126	case k.OutgoingCircuit.ChanID == hop.Exit:	×
127	return k.IncomingCircuit.String()	×
128
129	default:	×
130	return fmt.Sprintf("%v -> %v", k.IncomingCircuit,	×
131	k.OutgoingCircuit)	×
132	}
133	}
134
135	// HtlcInfo provides the details of a htlc that our node has processed. For
136	// forwards, incoming and outgoing values are set, whereas sends and receives
137	// will only have outgoing or incoming details set.
138	type HtlcInfo struct {
139	// IncomingTimelock is the time lock of the htlc on our incoming
140	// channel.
141	IncomingTimeLock uint32
142
143	// OutgoingTimelock is the time lock the htlc on our outgoing channel.
144	OutgoingTimeLock uint32
145
146	// IncomingAmt is the amount of the htlc on our incoming channel.
147	IncomingAmt lnwire.MilliSatoshi
148
149	// OutgoingAmt is the amount of the htlc on our outgoing channel.
150	OutgoingAmt lnwire.MilliSatoshi
151	}
152
153	// String returns a string representation of a htlc.
154	func (h HtlcInfo) String() string {	×
155	var details []string	×
156		×
157	// If the incoming information is not zero, as is the case for a send,	×
158	// we include the incoming amount and timelock.	×
159	if h.IncomingAmt != 0 \|\| h.IncomingTimeLock != 0 {	×
160	str := fmt.Sprintf("incoming amount: %v, "+	×
161	"incoming timelock: %v", h.IncomingAmt,	×
162	h.IncomingTimeLock)	×
163		×
164	details = append(details, str)	×
165	}	×
166
167	// If the outgoing information is not zero, as is the case for a
168	// receive, we include the outgoing amount and timelock.
169	if h.OutgoingAmt != 0 \|\| h.OutgoingTimeLock != 0 {	×
170	str := fmt.Sprintf("outgoing amount: %v, "+	×
171	"outgoing timelock: %v", h.OutgoingAmt,	×
172	h.OutgoingTimeLock)	×
173		×
174	details = append(details, str)	×
175	}	×
176
177	return strings.Join(details, ", ")	×
178	}
179
180	// HtlcEventType represents the type of event that a htlc was part of.
181	type HtlcEventType int
182
183	const (
184	// HtlcEventTypeSend represents a htlc that was part of a send from
185	// our node.
186	HtlcEventTypeSend HtlcEventType = iota
187
188	// HtlcEventTypeReceive represents a htlc that was part of a receive
189	// to our node.
190	HtlcEventTypeReceive
191
192	// HtlcEventTypeForward represents a htlc that was forwarded through
193	// our node.
194	HtlcEventTypeForward
195	)
196
197	// String returns a string representation of a htlc event type.
198	func (h HtlcEventType) String() string {	×
199	switch h {	×
200	case HtlcEventTypeSend:	×
201	return "send"	×
202
203	case HtlcEventTypeReceive:	×
204	return "receive"	×
205
206	case HtlcEventTypeForward:	×
207	return "forward"	×
208
209	default:	×
210	return "unknown"	×
211	}
212	}
213
214	// ForwardingEvent represents a htlc that was forwarded onwards from our node.
215	// Sends which originate from our node will report forward events with zero
216	// incoming circuits in their htlc key.
217	type ForwardingEvent struct {
218	// HtlcKey uniquely identifies the htlc, and can be used to match the
219	// forwarding event with subsequent settle/fail events.
220	HtlcKey
221
222	// HtlcInfo contains details about the htlc.
223	HtlcInfo
224
225	// HtlcEventType classifies the event as part of a local send or
226	// receive, or as part of a forward.
227	HtlcEventType
228
229	// Timestamp is the time when this htlc was forwarded.
230	Timestamp time.Time
231	}
232
233	// LinkFailEvent describes a htlc that failed on our incoming or outgoing
234	// link. The incoming bool is true for failures on incoming links, and false
235	// for failures on outgoing links. The failure reason is provided by a lnwire
236	// failure message which is enriched with a failure detail in the cases where
237	// the wire failure message does not contain full information about the
238	// failure.
239	type LinkFailEvent struct {
240	// HtlcKey uniquely identifies the htlc.
241	HtlcKey
242
243	// HtlcInfo contains details about the htlc.
244	HtlcInfo
245
246	// HtlcEventType classifies the event as part of a local send or
247	// receive, or as part of a forward.
248	HtlcEventType
249
250	// LinkError is the reason that we failed the htlc.
251	LinkError *LinkError
252
253	// Incoming is true if the htlc was failed on an incoming link.
254	// If it failed on the outgoing link, it is false.
255	Incoming bool
256
257	// Timestamp is the time when the link failure occurred.
258	Timestamp time.Time
259	}
260
261	// ForwardingFailEvent represents a htlc failure which occurred down the line
262	// after we forwarded a htlc onwards. An error is not included in this event
263	// because errors returned down the route are encrypted. HtlcInfo is not
264	// reliably available for forwarding failures, so it is omitted. These events
265	// should be matched with their corresponding forward event to obtain this
266	// information.
267	type ForwardingFailEvent struct {
268	// HtlcKey uniquely identifies the htlc, and can be used to match the
269	// htlc with its corresponding forwarding event.
270	HtlcKey
271
272	// HtlcEventType classifies the event as part of a local send or
273	// receive, or as part of a forward.
274	HtlcEventType
275
276	// Timestamp is the time when the forwarding failure was received.
277	Timestamp time.Time
278	}
279
280	// SettleEvent represents a htlc that was settled. HtlcInfo is not reliably
281	// available for forwarding failures, so it is omitted. These events should
282	// be matched with corresponding forward events or invoices (for receives)
283	// to obtain additional information about the htlc.
284	type SettleEvent struct {
285	// HtlcKey uniquely identifies the htlc, and can be used to match
286	// forwards with their corresponding forwarding event.
287	HtlcKey
288
289	// Preimage that was released for settling the htlc.
290	Preimage lntypes.Preimage
291
292	// HtlcEventType classifies the event as part of a local send or
293	// receive, or as part of a forward.
294	HtlcEventType
295
296	// Timestamp is the time when this htlc was settled.
297	Timestamp time.Time
298	}
299
300	type FinalHtlcEvent struct {
301	CircuitKey
302
303	Settled bool
304
305	// Offchain is indicating whether the htlc was resolved off-chain.
306	Offchain bool
307
308	// Timestamp is the time when this htlc was settled.
309	Timestamp time.Time
310	}
311
312	// NotifyForwardingEvent notifies the HtlcNotifier than a htlc has been
313	// forwarded.
314	//
315	// Note this is part of the htlcNotifier interface.
316	func (h *HtlcNotifier) NotifyForwardingEvent(key HtlcKey, info HtlcInfo,
317	eventType HtlcEventType) {	3✔
318		3✔
319	event := &ForwardingEvent{	3✔
320	HtlcKey: key,	3✔
321	HtlcInfo: info,	3✔
322	HtlcEventType: eventType,	3✔
323	Timestamp: h.now(),	3✔
324	}	3✔
325		3✔
326	log.Tracef("Notifying forward event: %v over %v, %v", eventType, key,	3✔
327	info)	3✔
328		3✔
329	if err := h.ntfnServer.SendUpdate(event); err != nil {	3✔
330	log.Warnf("Unable to send forwarding event: %v", err)	×
331	}	×
332	}
333
334	// NotifyLinkFailEvent notifies that a htlc has failed on our incoming
335	// or outgoing link.
336	//
337	// Note this is part of the htlcNotifier interface.
338	func (h *HtlcNotifier) NotifyLinkFailEvent(key HtlcKey, info HtlcInfo,
339	eventType HtlcEventType, linkErr *LinkError, incoming bool) {	3✔
340		3✔
341	event := &LinkFailEvent{	3✔
342	HtlcKey: key,	3✔
343	HtlcInfo: info,	3✔
344	HtlcEventType: eventType,	3✔
345	LinkError: linkErr,	3✔
346	Incoming: incoming,	3✔
347	Timestamp: h.now(),	3✔
348	}	3✔
349		3✔
350	log.Tracef("Notifying link failure event: %v over %v, %v", eventType,	3✔
351	key, info)	3✔
352		3✔
353	if err := h.ntfnServer.SendUpdate(event); err != nil {	3✔
354	log.Warnf("Unable to send link fail event: %v", err)	×
355	}	×
356	}
357
358	// NotifyForwardingFailEvent notifies the HtlcNotifier that a htlc we
359	// forwarded has failed down the line.
360	//
361	// Note this is part of the htlcNotifier interface.
362	func (h *HtlcNotifier) NotifyForwardingFailEvent(key HtlcKey,
363	eventType HtlcEventType) {	3✔
364		3✔
365	event := &ForwardingFailEvent{	3✔
366	HtlcKey: key,	3✔
367	HtlcEventType: eventType,	3✔
368	Timestamp: h.now(),	3✔
369	}	3✔
370		3✔
371	log.Tracef("Notifying forwarding failure event: %v over %v", eventType,	3✔
372	key)	3✔
373		3✔
374	if err := h.ntfnServer.SendUpdate(event); err != nil {	3✔
375	log.Warnf("Unable to send forwarding fail event: %v", err)	×
376	}	×
377	}
378
379	// NotifySettleEvent notifies the HtlcNotifier that a htlc that we committed
380	// to as part of a forward or a receive to our node has been settled.
381	//
382	// Note this is part of the htlcNotifier interface.
383	func (h *HtlcNotifier) NotifySettleEvent(key HtlcKey,
384	preimage lntypes.Preimage, eventType HtlcEventType) {	3✔
385		3✔
386	event := &SettleEvent{	3✔
387	HtlcKey: key,	3✔
388	Preimage: preimage,	3✔
389	HtlcEventType: eventType,	3✔
390	Timestamp: h.now(),	3✔
391	}	3✔
392		3✔
393	log.Tracef("Notifying settle event: %v over %v", eventType, key)	3✔
394		3✔
395	if err := h.ntfnServer.SendUpdate(event); err != nil {	3✔
396	log.Warnf("Unable to send settle event: %v", err)	×
397	}	×
398	}
399
400	// NotifyFinalHtlcEvent notifies the HtlcNotifier that the final outcome for an
401	// htlc has been determined.
402	//
403	// Note this is part of the htlcNotifier interface.
404	func (h *HtlcNotifier) NotifyFinalHtlcEvent(key models.CircuitKey,
405	info channeldb.FinalHtlcInfo) {	3✔
406		3✔
407	event := &FinalHtlcEvent{	3✔
408	CircuitKey: key,	3✔
409	Settled: info.Settled,	3✔
410	Offchain: info.Offchain,	3✔
411	Timestamp: h.now(),	3✔
412	}	3✔
413		3✔
414	log.Tracef("Notifying final settle event: %v", key)	3✔
415		3✔
416	if err := h.ntfnServer.SendUpdate(event); err != nil {	3✔
417	log.Warnf("Unable to send settle event: %v", err)	×
418	}	×
419	}
420
421	// newHtlc key returns a htlc key for the packet provided. If the packet
422	// has a zero incoming channel ID, the packet is for one of our own sends,
423	// which has the payment id stashed in the incoming htlc id. If this is the
424	// case, we replace the incoming htlc id with zero so that the notifier
425	// consistently reports zero circuit keys for events that terminate or
426	// originate at our node.
427	func newHtlcKey(pkt *htlcPacket) HtlcKey {	3✔
428	htlcKey := HtlcKey{	3✔
429	IncomingCircuit: models.CircuitKey{	3✔
430	ChanID: pkt.incomingChanID,	3✔
431	HtlcID: pkt.incomingHTLCID,	3✔
432	},	3✔
433	OutgoingCircuit: CircuitKey{	3✔
434	ChanID: pkt.outgoingChanID,	3✔
435	HtlcID: pkt.outgoingHTLCID,	3✔
436	},	3✔
437	}	3✔
438		3✔
439	// If the packet has a zero incoming channel ID, it is a send that was	3✔
440	// initiated at our node. If this is the case, our internal pid is in	3✔
441	// the incoming htlc ID, so we overwrite it with 0 for notification	3✔
442	// purposes.	3✔
443	if pkt.incomingChanID == hop.Source {	6✔
444	htlcKey.IncomingCircuit.HtlcID = 0	3✔
445	}	3✔
446
447	return htlcKey	3✔
448	}
449
450	// newHtlcInfo returns HtlcInfo for the packet provided.
451	func newHtlcInfo(pkt *htlcPacket) HtlcInfo {	3✔
452	return HtlcInfo{	3✔
453	IncomingTimeLock: pkt.incomingTimeout,	3✔
454	OutgoingTimeLock: pkt.outgoingTimeout,	3✔
455	IncomingAmt: pkt.incomingAmount,	3✔
456	OutgoingAmt: pkt.amount,	3✔
457	}	3✔
458	}	3✔
459
460	// getEventType returns the htlc type based on the fields set in the htlc
461	// packet. Sends that originate at our node have the source (zero) incoming
462	// channel ID. Receives to our node have the exit (zero) outgoing channel ID
463	// and forwards have both fields set.
464	func getEventType(pkt *htlcPacket) HtlcEventType {	3✔
465	switch {	3✔
466	case pkt.incomingChanID == hop.Source:	3✔
467	return HtlcEventTypeSend	3✔
468
UNCOV 469	case pkt.outgoingChanID == hop.Exit:	×
UNCOV 470	return HtlcEventTypeReceive	×
471
472	default:	3✔
473	return HtlcEventTypeForward	3✔
474	}
475	}

lightningnetwork / lnd / 13211764208

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