13236757158

Committed 10 Feb 2025 08:39AM UTC coverage: 57.649% (-1.2%) from 58.815%

Build # 13236757158

Build Type

Pull #9493

github

Committed by

ziggie1984

Commit Message

lncli: for some cmds we don't replace the data of the response.

For some cmds it is not very practical to replace the json output
because we might pipe it into other commands. For example when
creating the route we want to pipe it into sendtoRoute.

Pull Request Pull Request #9493: For some lncli cmds we should not replace the content with other data

Run Details

0 of 9 new or added lines in 2 files covered. (0.0%)

19535 existing lines in 252 files now uncovered.

103517 of 179563 relevant lines covered (57.65%)

24878.49 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 / 13236757158

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