12986279612

Committed 27 Jan 2025 09:51AM UTC coverage: 57.652% (-1.1%) from 58.788%

Build # 12986279612

Build Type

Pull #9447

github

Committed by

yyforyongyu

Commit Message

sweep: rename methods for clarity

We now rename "third party" to "unknown" as the inputs can be spent via
an older sweeping tx, a third party (anchor), or a remote party (pin).
In fee bumper we don't have the info to distinguish the above cases, and
leave them to be further handled by the sweeper as it has more context.

Pull Request Pull Request #9447: sweep: start tracking input spending status in the fee bumper

Run Details

83 of 87 new or added lines in 2 files covered. (95.4%)

19578 existing lines in 256 files now uncovered.

103448 of 179434 relevant lines covered (57.65%)

24884.58 hits per line

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

31.25

/intercepted_forward.go

package lnd

import (
        "errors"

        "github.com/lightningnetwork/lnd/fn/v2"
        "github.com/lightningnetwork/lnd/htlcswitch"
        "github.com/lightningnetwork/lnd/lntypes"
        "github.com/lightningnetwork/lnd/lnwire"
)

var (
        // ErrCannotResume is returned when an intercepted forward cannot be
        // resumed. This is the case in the on-chain resolution flow.
        ErrCannotResume = errors.New("cannot resume in the on-chain flow")

        // ErrCannotFail is returned when an intercepted forward cannot be failed.
        // This is the case in the on-chain resolution flow.
        ErrCannotFail = errors.New("cannot fail in the on-chain flow")

        // ErrPreimageMismatch is returned when the preimage that is specified to
        // settle an htlc doesn't match the htlc hash.
        ErrPreimageMismatch = errors.New("preimage does not match hash")
)

// interceptedForward implements the on-chain behavior for the resolution of
// a forwarded htlc.
type interceptedForward struct {
        packet *htlcswitch.InterceptedPacket
        beacon *preimageBeacon
}

func newInterceptedForward(
        packet *htlcswitch.InterceptedPacket,
        beacon *preimageBeacon) *interceptedForward {

        return &interceptedForward{
                beacon: beacon,
                packet: packet,
        }
}

// Packet returns the intercepted htlc packet.
func (f *interceptedForward) Packet() htlcswitch.InterceptedPacket {
        return *f.packet
}

// Resume notifies the intention to resume an existing hold forward. This
// basically means the caller wants to resume with the default behavior for this
// htlc which usually means forward it.
func (f *interceptedForward) Resume() error {
        return ErrCannotResume
}

// ResumeModified notifies the intention to resume an existing hold forward with
// a modified htlc.
func (f *interceptedForward) ResumeModified(_, _ fn.Option[lnwire.MilliSatoshi],
        _ fn.Option[lnwire.CustomRecords]) error {

        return ErrCannotResume
}

// Fail notifies the intention to fail an existing hold forward with an
// encrypted failure reason.
func (f *interceptedForward) Fail(_ []byte) error {
        // We can't actively fail an htlc. The best we could do is abandon the
        // resolver, but this wouldn't be a safe operation. There may be a race
        // with the preimage beacon supplying a preimage. Therefore we don't
        // attempt to fail and just return an error here.
        return ErrCannotFail
}

// FailWithCode notifies the intention to fail an existing hold forward with the
// specified failure code.
func (f *interceptedForward) FailWithCode(_ lnwire.FailCode) error {
        return ErrCannotFail
}

// Settle notifies the intention to settle an existing hold forward with a given
// preimage.
func (f *interceptedForward) Settle(preimage lntypes.Preimage) error {
        if !preimage.Matches(f.packet.Hash) {
                return ErrPreimageMismatch
        }

        // Add preimage to the preimage beacon. The onchain resolver will pick
        // up the preimage from the beacon.
        return f.beacon.AddPreimages(preimage)
}

1	package lnd
2
3	import (
4	"errors"
5
6	"github.com/lightningnetwork/lnd/fn/v2"
7	"github.com/lightningnetwork/lnd/htlcswitch"
8	"github.com/lightningnetwork/lnd/lntypes"
9	"github.com/lightningnetwork/lnd/lnwire"
10	)
11
12	var (
13	// ErrCannotResume is returned when an intercepted forward cannot be
14	// resumed. This is the case in the on-chain resolution flow.
15	ErrCannotResume = errors.New("cannot resume in the on-chain flow")
16
17	// ErrCannotFail is returned when an intercepted forward cannot be failed.
18	// This is the case in the on-chain resolution flow.
19	ErrCannotFail = errors.New("cannot fail in the on-chain flow")
20
21	// ErrPreimageMismatch is returned when the preimage that is specified to
22	// settle an htlc doesn't match the htlc hash.
23	ErrPreimageMismatch = errors.New("preimage does not match hash")
24	)
25
26	// interceptedForward implements the on-chain behavior for the resolution of
27	// a forwarded htlc.
28	type interceptedForward struct {
29	packet *htlcswitch.InterceptedPacket
30	beacon *preimageBeacon
31	}
32
33	func newInterceptedForward(
34	packet *htlcswitch.InterceptedPacket,
35	beacon preimageBeacon) interceptedForward {	1✔
36		1✔
37	return &interceptedForward{	1✔
38	beacon: beacon,	1✔
39	packet: packet,	1✔
40	}	1✔
41	}	1✔
42
43	// Packet returns the intercepted htlc packet.
UNCOV 44	func (f *interceptedForward) Packet() htlcswitch.InterceptedPacket {	×
UNCOV 45	return *f.packet	×
UNCOV 46	}	×
47
48	// Resume notifies the intention to resume an existing hold forward. This
49	// basically means the caller wants to resume with the default behavior for this
50	// htlc which usually means forward it.
51	func (f *interceptedForward) Resume() error {	×
52	return ErrCannotResume	×
53	}	×
54
55	// ResumeModified notifies the intention to resume an existing hold forward with
56	// a modified htlc.
57	func (f *interceptedForward) ResumeModified(_, _ fn.Option[lnwire.MilliSatoshi],
58	_ fn.Option[lnwire.CustomRecords]) error {	×
59		×
60	return ErrCannotResume	×
61	}	×
62
63	// Fail notifies the intention to fail an existing hold forward with an
64	// encrypted failure reason.
65	func (f *interceptedForward) Fail(_ []byte) error {	×
66	// We can't actively fail an htlc. The best we could do is abandon the	×
67	// resolver, but this wouldn't be a safe operation. There may be a race	×
68	// with the preimage beacon supplying a preimage. Therefore we don't	×
69	// attempt to fail and just return an error here.	×
70	return ErrCannotFail	×
71	}	×
72
73	// FailWithCode notifies the intention to fail an existing hold forward with the
74	// specified failure code.
75	func (f *interceptedForward) FailWithCode(_ lnwire.FailCode) error {	×
76	return ErrCannotFail	×
77	}	×
78
79	// Settle notifies the intention to settle an existing hold forward with a given
80	// preimage.
81	func (f *interceptedForward) Settle(preimage lntypes.Preimage) error {	1✔
82	if !preimage.Matches(f.packet.Hash) {	1✔
83	return ErrPreimageMismatch	×
84	}	×
85
86	// Add preimage to the preimage beacon. The onchain resolver will pick
87	// up the preimage from the beacon.
88	return f.beacon.AddPreimages(preimage)	1✔
89	}

lightningnetwork / lnd / 12986279612

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