12199391122

Committed 06 Dec 2024 01:10PM UTC coverage: 49.807% (-9.1%) from 58.933%

Build # 12199391122

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #9337 from Guayaba221/patch-1

chore: fix typo in ruby.md

Run Details

100137 of 201051 relevant lines covered (49.81%)

2.07 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"
        "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"
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 {	4✔
36		4✔
37	return &interceptedForward{	4✔
38	beacon: beacon,	4✔
39	packet: packet,	4✔
40	}	4✔
41	}	4✔
42
43	// Packet returns the intercepted htlc packet.
44	func (f *interceptedForward) Packet() htlcswitch.InterceptedPacket {	4✔
45	return *f.packet	4✔
46	}	4✔
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 {	×
82	if !preimage.Matches(f.packet.Hash) {	×
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)	×
89	}

lightningnetwork / lnd / 12199391122

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