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

75.0

/watchtower/blob/type.go

package blob

import (
        "fmt"
        "strings"

        "github.com/lightningnetwork/lnd/channeldb"
)

// Flag represents a specify option that can be present in a Type.
type Flag uint16

const (
        // FlagReward signals that the justice transaction should contain an
        // additional output for itself. Signatures sent by the client should
        // include the reward script negotiated during session creation. Without
        // the flag, there is only one output sweeping clients funds back to
        // them solely.
        FlagReward Flag = 1

        // FlagCommitOutputs signals that the blob contains the information
        // required to sweep commitment outputs.
        FlagCommitOutputs Flag = 1 << 1

        // FlagAnchorChannel signals that this blob is meant to spend an anchor
        // channel, and therefore must expect a P2WSH-style to-remote output if
        // one exists.
        FlagAnchorChannel Flag = 1 << 2

        // FlagTaprootChannel signals that this blob is meant to spend a
        // taproot channel and therefore must expect P2TR outputs.
        FlagTaprootChannel Flag = 1 << 3
)

// Type returns a Type consisting solely of this flag enabled.
func (f Flag) Type() Type {
        return Type(f)
}

// String returns the name of the flag.
func (f Flag) String() string {
        switch f {
        case FlagReward:
                return "FlagReward"
        case FlagCommitOutputs:
                return "FlagCommitOutputs"
        case FlagAnchorChannel:
                return "FlagAnchorChannel"
        case FlagTaprootChannel:
                return "FlagTaprootChannel"
        default:
                return "FlagUnknown"
        }
}

// Type is a bit vector composed of Flags that govern various aspects of
// reconstructing the justice transaction from an encrypted blob. The flags can
// be used to signal behaviors such as which inputs are being swept, which
// outputs should be added to the justice transaction, or modify serialization
// of the blob itself.
type Type uint16

const (
        // TypeAltruistCommit sweeps only commitment outputs to a sweep address
        // controlled by the user, and does not give the tower a reward.
        TypeAltruistCommit = Type(FlagCommitOutputs)

        // TypeAltruistAnchorCommit sweeps only commitment outputs from an
        // anchor commitment to a sweep address controlled by the user, and does
        // not give the tower a reward.
        TypeAltruistAnchorCommit = Type(FlagCommitOutputs | FlagAnchorChannel)

        // TypeRewardCommit sweeps only commitment outputs to a sweep address
        // controlled by the user, and pays a negotiated reward to the tower.
        TypeRewardCommit = Type(FlagCommitOutputs | FlagReward)

        // TypeAltruistTaprootCommit sweeps only the commitment outputs from a
        // taproot channel commitment to a sweep address controlled by the user,
        // and does not give the tower a reward.
        TypeAltruistTaprootCommit = Type(FlagCommitOutputs | FlagTaprootChannel)
)

// TypeFromChannel returns the appropriate blob Type for the given channel
// type.
func TypeFromChannel(chanType channeldb.ChannelType) Type {
        switch {
        case chanType.IsTaproot():
                return TypeAltruistTaprootCommit
        case chanType.HasAnchors():
                return TypeAltruistAnchorCommit
        default:
                return TypeAltruistCommit
        }
}

// Identifier returns a unique, stable string identifier for the blob Type.
func (t Type) Identifier() (string, error) {
        switch t {
        case TypeAltruistCommit:
                return "legacy", nil
        case TypeAltruistAnchorCommit:
                return "anchor", nil
        case TypeRewardCommit:
                return "reward", nil
        case TypeAltruistTaprootCommit:
                return "taproot", nil
        default:
                return "", fmt.Errorf("unknown blob type: %v", t)
        }
}

// CommitmentType returns the appropriate CommitmentType for the given blob Type
// and channel type.
func (t Type) CommitmentType(chanType *channeldb.ChannelType) (CommitmentType,
        error) {

        switch {
        case t.Has(FlagTaprootChannel):
                return TaprootCommitment, nil

        case t.Has(FlagAnchorChannel):
                return AnchorCommitment, nil

        case t.Has(FlagCommitOutputs):
                if chanType != nil && chanType.IsTweakless() {
                        return LegacyTweaklessCommitment, nil
                }

                return LegacyCommitment, nil

        default:
                return 0, ErrUnknownBlobType
        }
}

// Has returns true if the Type has the passed flag enabled.
func (t Type) Has(flag Flag) bool {
        return Flag(t)&flag == flag
}

// TypeFromFlags creates a single Type from an arbitrary list of flags.
func TypeFromFlags(flags ...Flag) Type {
        var typ Type
        for _, flag := range flags {
                typ |= Type(flag)
        }

        return typ
}

// IsAnchorChannel returns true if the blob type is for an anchor channel.
func (t Type) IsAnchorChannel() bool {
        return t.Has(FlagAnchorChannel)
}

// IsTaprootChannel returns true if the blob type is for a taproot channel.
func (t Type) IsTaprootChannel() bool {
        return t.Has(FlagTaprootChannel)
}

// knownFlags maps the supported flags to their name.
var knownFlags = map[Flag]struct{}{
        FlagReward:         {},
        FlagCommitOutputs:  {},
        FlagAnchorChannel:  {},
        FlagTaprootChannel: {},
}

// String returns a human-readable description of a Type.
func (t Type) String() string {
        var (
                hrPieces        []string
                hasUnknownFlags bool
        )

        // Iterate through the possible flags from highest to lowest. This will
        // ensure that the human readable names will be in the same order as the
        // bits (left to right) if the type were to be printed in big-endian
        // byte order.
        for f := Flag(1 << 15); f != 0; f >>= 1 {
                // If this flag is known, we'll add a human-readable name or its
                // inverse depending on whether the type has this flag set.
                if _, ok := knownFlags[f]; ok {
                        if t.Has(f) {
                                hrPieces = append(hrPieces, f.String())
                        } else {
                                hrPieces = append(hrPieces, "No-"+f.String())
                        }
                } else {
                        // Make note of any unknown flags that this type has
                        // set. If any are present, we'll prepend the bit-wise
                        // representation of the type in the final string.
                        if t.Has(f) {
                                hasUnknownFlags = true
                        }
                }
        }

        // If there were no unknown flags, we'll simply return the list of human
        // readable pieces.
        if !hasUnknownFlags {
                return fmt.Sprintf("[%s]", strings.Join(hrPieces, "|"))
        }

        // Otherwise, we'll prepend the bit-wise representation to the human
        // readable names.
        return fmt.Sprintf("%016b[%s]", t, strings.Join(hrPieces, "|"))
}

// supportedTypes is the set of all configurations known to be supported by the
// package.
var supportedTypes = map[Type]struct{}{
        TypeAltruistCommit:        {},
        TypeRewardCommit:          {},
        TypeAltruistAnchorCommit:  {},
        TypeAltruistTaprootCommit: {},
}

// IsSupportedType returns true if the given type is supported by the package.
func IsSupportedType(blobType Type) bool {
        _, ok := supportedTypes[blobType]
        return ok
}

// SupportedTypes returns a list of all supported blob types.
func SupportedTypes() []Type {
        supported := make([]Type, 0, len(supportedTypes))
        for t := range supportedTypes {
                supported = append(supported, t)
        }
        return supported
}

1	package blob
2
3	import (
4	"fmt"
5	"strings"
6
7	"github.com/lightningnetwork/lnd/channeldb"
8	)
9
10	// Flag represents a specify option that can be present in a Type.
11	type Flag uint16
12
13	const (
14	// FlagReward signals that the justice transaction should contain an
15	// additional output for itself. Signatures sent by the client should
16	// include the reward script negotiated during session creation. Without
17	// the flag, there is only one output sweeping clients funds back to
18	// them solely.
19	FlagReward Flag = 1
20
21	// FlagCommitOutputs signals that the blob contains the information
22	// required to sweep commitment outputs.
23	FlagCommitOutputs Flag = 1 << 1
24
25	// FlagAnchorChannel signals that this blob is meant to spend an anchor
26	// channel, and therefore must expect a P2WSH-style to-remote output if
27	// one exists.
28	FlagAnchorChannel Flag = 1 << 2
29
30	// FlagTaprootChannel signals that this blob is meant to spend a
31	// taproot channel and therefore must expect P2TR outputs.
32	FlagTaprootChannel Flag = 1 << 3
33	)
34
35	// Type returns a Type consisting solely of this flag enabled.
36	func (f Flag) Type() Type {	×
37	return Type(f)	×
38	}	×
39
40	// String returns the name of the flag.
41	func (f Flag) String() string {	4✔
42	switch f {	4✔
43	case FlagReward:	4✔
44	return "FlagReward"	4✔
45	case FlagCommitOutputs:	4✔
46	return "FlagCommitOutputs"	4✔
47	case FlagAnchorChannel:	4✔
48	return "FlagAnchorChannel"	4✔
49	case FlagTaprootChannel:	4✔
50	return "FlagTaprootChannel"	4✔
51	default:	×
52	return "FlagUnknown"	×
53	}
54	}
55
56	// Type is a bit vector composed of Flags that govern various aspects of
57	// reconstructing the justice transaction from an encrypted blob. The flags can
58	// be used to signal behaviors such as which inputs are being swept, which
59	// outputs should be added to the justice transaction, or modify serialization
60	// of the blob itself.
61	type Type uint16
62
63	const (
64	// TypeAltruistCommit sweeps only commitment outputs to a sweep address
65	// controlled by the user, and does not give the tower a reward.
66	TypeAltruistCommit = Type(FlagCommitOutputs)
67
68	// TypeAltruistAnchorCommit sweeps only commitment outputs from an
69	// anchor commitment to a sweep address controlled by the user, and does
70	// not give the tower a reward.
71	TypeAltruistAnchorCommit = Type(FlagCommitOutputs \| FlagAnchorChannel)
72
73	// TypeRewardCommit sweeps only commitment outputs to a sweep address
74	// controlled by the user, and pays a negotiated reward to the tower.
75	TypeRewardCommit = Type(FlagCommitOutputs \| FlagReward)
76
77	// TypeAltruistTaprootCommit sweeps only the commitment outputs from a
78	// taproot channel commitment to a sweep address controlled by the user,
79	// and does not give the tower a reward.
80	TypeAltruistTaprootCommit = Type(FlagCommitOutputs \| FlagTaprootChannel)
81	)
82
83	// TypeFromChannel returns the appropriate blob Type for the given channel
84	// type.
85	func TypeFromChannel(chanType channeldb.ChannelType) Type {	4✔
86	switch {	4✔
87	case chanType.IsTaproot():	4✔
88	return TypeAltruistTaprootCommit	4✔
89	case chanType.HasAnchors():	4✔
90	return TypeAltruistAnchorCommit	4✔
91	default:	4✔
92	return TypeAltruistCommit	4✔
93	}
94	}
95
96	// Identifier returns a unique, stable string identifier for the blob Type.
97	func (t Type) Identifier() (string, error) {	4✔
98	switch t {	4✔
99	case TypeAltruistCommit:	4✔
100	return "legacy", nil	4✔
101	case TypeAltruistAnchorCommit:	4✔
102	return "anchor", nil	4✔
103	case TypeRewardCommit:	×
104	return "reward", nil	×
105	case TypeAltruistTaprootCommit:	4✔
106	return "taproot", nil	4✔
107	default:	×
108	return "", fmt.Errorf("unknown blob type: %v", t)	×
109	}
110	}
111
112	// CommitmentType returns the appropriate CommitmentType for the given blob Type
113	// and channel type.
114	func (t Type) CommitmentType(chanType *channeldb.ChannelType) (CommitmentType,
115	error) {	4✔
116		4✔
117	switch {	4✔
118	case t.Has(FlagTaprootChannel):	4✔
119	return TaprootCommitment, nil	4✔
120
121	case t.Has(FlagAnchorChannel):	4✔
122	return AnchorCommitment, nil	4✔
123
124	case t.Has(FlagCommitOutputs):	4✔
125	if chanType != nil && chanType.IsTweakless() {	8✔
126	return LegacyTweaklessCommitment, nil	4✔
127	}	4✔
128
129	return LegacyCommitment, nil	4✔
130
131	default:	×
132	return 0, ErrUnknownBlobType	×
133	}
134	}
135
136	// Has returns true if the Type has the passed flag enabled.
137	func (t Type) Has(flag Flag) bool {	4✔
138	return Flag(t)&flag == flag	4✔
139	}	4✔
140
141	// TypeFromFlags creates a single Type from an arbitrary list of flags.
142	func TypeFromFlags(flags ...Flag) Type {	×
143	var typ Type	×
144	for _, flag := range flags {	×
145	typ \|= Type(flag)	×
146	}	×
147
148	return typ	×
149	}
150
151	// IsAnchorChannel returns true if the blob type is for an anchor channel.
152	func (t Type) IsAnchorChannel() bool {	4✔
153	return t.Has(FlagAnchorChannel)	4✔
154	}	4✔
155
156	// IsTaprootChannel returns true if the blob type is for a taproot channel.
157	func (t Type) IsTaprootChannel() bool {	4✔
158	return t.Has(FlagTaprootChannel)	4✔
159	}	4✔
160
161	// knownFlags maps the supported flags to their name.
162	var knownFlags = map[Flag]struct{}{
163	FlagReward: {},
164	FlagCommitOutputs: {},
165	FlagAnchorChannel: {},
166	FlagTaprootChannel: {},
167	}
168
169	// String returns a human-readable description of a Type.
170	func (t Type) String() string {	4✔
171	var (	4✔
172	hrPieces []string	4✔
173	hasUnknownFlags bool	4✔
174	)	4✔
175		4✔
176	// Iterate through the possible flags from highest to lowest. This will	4✔
177	// ensure that the human readable names will be in the same order as the	4✔
178	// bits (left to right) if the type were to be printed in big-endian	4✔
179	// byte order.	4✔
180	for f := Flag(1 << 15); f != 0; f >>= 1 {	8✔
181	// If this flag is known, we'll add a human-readable name or its	4✔
182	// inverse depending on whether the type has this flag set.	4✔
183	if _, ok := knownFlags[f]; ok {	8✔
184	if t.Has(f) {	8✔
185	hrPieces = append(hrPieces, f.String())	4✔
186	} else {	8✔
187	hrPieces = append(hrPieces, "No-"+f.String())	4✔
188	}	4✔
189	} else {	4✔
190	// Make note of any unknown flags that this type has	4✔
191	// set. If any are present, we'll prepend the bit-wise	4✔
192	// representation of the type in the final string.	4✔
193	if t.Has(f) {	4✔
194	hasUnknownFlags = true	×
195	}	×
196	}
197	}
198
199	// If there were no unknown flags, we'll simply return the list of human
200	// readable pieces.
201	if !hasUnknownFlags {	8✔
202	return fmt.Sprintf("[%s]", strings.Join(hrPieces, "\|"))	4✔
203	}	4✔
204
205	// Otherwise, we'll prepend the bit-wise representation to the human
206	// readable names.
207	return fmt.Sprintf("%016b[%s]", t, strings.Join(hrPieces, "\|"))	×
208	}
209
210	// supportedTypes is the set of all configurations known to be supported by the
211	// package.
212	var supportedTypes = map[Type]struct{}{
213	TypeAltruistCommit: {},
214	TypeRewardCommit: {},
215	TypeAltruistAnchorCommit: {},
216	TypeAltruistTaprootCommit: {},
217	}
218
219	// IsSupportedType returns true if the given type is supported by the package.
220	func IsSupportedType(blobType Type) bool {	4✔
221	_, ok := supportedTypes[blobType]	4✔
222	return ok	4✔
223	}	4✔
224
225	// SupportedTypes returns a list of all supported blob types.
226	func SupportedTypes() []Type {	×
227	supported := make([]Type, 0, len(supportedTypes))	×
228	for t := range supportedTypes {	×
229	supported = append(supported, t)	×
230	}	×
231	return supported	×
232	}

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