15561477203

Committed 10 Jun 2025 01:54PM UTC coverage: 58.351% (-10.1%) from 68.487%

Build # 15561477203

Build Type

Pull #9356

github

Committed by

web-flow

Commit Message

Merge 6440b25db into c6d6d4c0b

Pull Request Pull Request #9356: lnrpc: add incoming/outgoing channel ids filter to forwarding history request

Run Details

33 of 36 new or added lines in 2 files covered. (91.67%)

28366 existing lines in 455 files now uncovered.

97715 of 167461 relevant lines covered (58.35%)

1.81 hits per line

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

68.42

/lnwire/channel_id.go

package lnwire

import (
        "encoding/binary"
        "encoding/hex"
        "math"

        "github.com/btcsuite/btcd/chaincfg/chainhash"
        "github.com/btcsuite/btcd/wire"
)

const (
        // MaxFundingTxOutputs is the maximum number of allowed outputs on a
        // funding transaction within the protocol. This is due to the fact
        // that we use 2-bytes to encode the index within the funding output
        // during the funding workflow. Funding transaction with more outputs
        // than this are considered invalid within the protocol.
        MaxFundingTxOutputs = math.MaxUint16
)

// ChannelID is a series of 32-bytes that uniquely identifies all channels
// within the network. The ChannelID is computed using the outpoint of the
// funding transaction (the txid, and output index). Given a funding output the
// ChannelID can be calculated by XOR'ing the big-endian serialization of the
// txid and the big-endian serialization of the output index, truncated to
// 2 bytes.
type ChannelID [32]byte

// ConnectionWideID is an all-zero ChannelID, which is used to represent a
// message intended for all channels to specific peer.
var ConnectionWideID = ChannelID{}

// String returns the string representation of the ChannelID. This is just the
// hex string encoding of the ChannelID itself.
func (c ChannelID) String() string {
        return hex.EncodeToString(c[:])
}

// NewChanIDFromOutPoint converts a target OutPoint into a ChannelID that is
// usable within the network. In order to convert the OutPoint into a ChannelID,
// we XOR the lower 2-bytes of the txid within the OutPoint with the big-endian
// serialization of the Index of the OutPoint, truncated to 2-bytes.
func NewChanIDFromOutPoint(op wire.OutPoint) ChannelID {
        // First we'll copy the txid of the outpoint into our channel ID slice.
        var cid ChannelID
        copy(cid[:], op.Hash[:])

        // With the txid copied over, we'll now XOR the lower 2-bytes of the
        // partial channelID with big-endian serialization of output index.
        xorTxid(&cid, uint16(op.Index))

        return cid
}

// xorTxid performs the transformation needed to transform an OutPoint into a
// ChannelID. To do this, we expect the cid parameter to contain the txid
// unaltered and the outputIndex to be the output index
func xorTxid(cid *ChannelID, outputIndex uint16) {
        var buf [2]byte
        binary.BigEndian.PutUint16(buf[:], outputIndex)

        cid[30] ^= buf[0]
        cid[31] ^= buf[1]
}

// GenPossibleOutPoints generates all the possible outputs given a channel ID.
// In order to generate these possible outpoints, we perform a brute-force
// search through the candidate output index space, performing a reverse
// mapping from channelID back to OutPoint.
func (c *ChannelID) GenPossibleOutPoints() [MaxFundingTxOutputs]wire.OutPoint {
        var possiblePoints [MaxFundingTxOutputs]wire.OutPoint
        for i := uint16(0); i < MaxFundingTxOutputs; i++ {
                cidCopy := *c
                xorTxid(&cidCopy, i)

                possiblePoints[i] = wire.OutPoint{
                        Hash:  chainhash.Hash(cidCopy),
                        Index: uint32(i),
                }
        }

        return possiblePoints
}

// IsChanPoint returns true if the OutPoint passed corresponds to the target
// ChannelID.
func (c ChannelID) IsChanPoint(op *wire.OutPoint) bool {
        candidateCid := NewChanIDFromOutPoint(*op)

        return candidateCid == c
}

1	package lnwire
2
3	import (
4	"encoding/binary"
5	"encoding/hex"
6	"math"
7
8	"github.com/btcsuite/btcd/chaincfg/chainhash"
9	"github.com/btcsuite/btcd/wire"
10	)
11
12	const (
13	// MaxFundingTxOutputs is the maximum number of allowed outputs on a
14	// funding transaction within the protocol. This is due to the fact
15	// that we use 2-bytes to encode the index within the funding output
16	// during the funding workflow. Funding transaction with more outputs
17	// than this are considered invalid within the protocol.
18	MaxFundingTxOutputs = math.MaxUint16
19	)
20
21	// ChannelID is a series of 32-bytes that uniquely identifies all channels
22	// within the network. The ChannelID is computed using the outpoint of the
23	// funding transaction (the txid, and output index). Given a funding output the
24	// ChannelID can be calculated by XOR'ing the big-endian serialization of the
25	// txid and the big-endian serialization of the output index, truncated to
26	// 2 bytes.
27	type ChannelID [32]byte
28
29	// ConnectionWideID is an all-zero ChannelID, which is used to represent a
30	// message intended for all channels to specific peer.
31	var ConnectionWideID = ChannelID{}
32
33	// String returns the string representation of the ChannelID. This is just the
34	// hex string encoding of the ChannelID itself.
35	func (c ChannelID) String() string {	3✔
36	return hex.EncodeToString(c[:])	3✔
37	}	3✔
38
39	// NewChanIDFromOutPoint converts a target OutPoint into a ChannelID that is
40	// usable within the network. In order to convert the OutPoint into a ChannelID,
41	// we XOR the lower 2-bytes of the txid within the OutPoint with the big-endian
42	// serialization of the Index of the OutPoint, truncated to 2-bytes.
43	func NewChanIDFromOutPoint(op wire.OutPoint) ChannelID {	3✔
44	// First we'll copy the txid of the outpoint into our channel ID slice.	3✔
45	var cid ChannelID	3✔
46	copy(cid[:], op.Hash[:])	3✔
47		3✔
48	// With the txid copied over, we'll now XOR the lower 2-bytes of the	3✔
49	// partial channelID with big-endian serialization of output index.	3✔
50	xorTxid(&cid, uint16(op.Index))	3✔
51		3✔
52	return cid	3✔
53	}	3✔
54
55	// xorTxid performs the transformation needed to transform an OutPoint into a
56	// ChannelID. To do this, we expect the cid parameter to contain the txid
57	// unaltered and the outputIndex to be the output index
58	func xorTxid(cid *ChannelID, outputIndex uint16) {	3✔
59	var buf [2]byte	3✔
60	binary.BigEndian.PutUint16(buf[:], outputIndex)	3✔
61		3✔
62	cid[30] ^= buf[0]	3✔
63	cid[31] ^= buf[1]	3✔
64	}	3✔
65
66	// GenPossibleOutPoints generates all the possible outputs given a channel ID.
67	// In order to generate these possible outpoints, we perform a brute-force
68	// search through the candidate output index space, performing a reverse
69	// mapping from channelID back to OutPoint.
UNCOV 70	func (c *ChannelID) GenPossibleOutPoints() [MaxFundingTxOutputs]wire.OutPoint {	×
UNCOV 71	var possiblePoints [MaxFundingTxOutputs]wire.OutPoint	×
UNCOV 72	for i := uint16(0); i < MaxFundingTxOutputs; i++ {	×
UNCOV 73	cidCopy := *c	×
UNCOV 74	xorTxid(&cidCopy, i)	×
UNCOV 75		×
UNCOV 76	possiblePoints[i] = wire.OutPoint{	×
UNCOV 77	Hash: chainhash.Hash(cidCopy),	×
UNCOV 78	Index: uint32(i),	×
UNCOV 79	}	×
UNCOV 80	}	×
81
UNCOV 82	return possiblePoints	×
83	}
84
85	// IsChanPoint returns true if the OutPoint passed corresponds to the target
86	// ChannelID.
87	func (c ChannelID) IsChanPoint(op *wire.OutPoint) bool {	3✔
88	candidateCid := NewChanIDFromOutPoint(*op)	3✔
89		3✔
90	return candidateCid == c	3✔
91	}	3✔

lightningnetwork / lnd / 15561477203

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