13035292482

Committed 29 Jan 2025 03:59PM UTC coverage: 49.3% (-9.5%) from 58.777%

Build # 13035292482

Build Type

Pull #9456

github

Committed by

mohamedawnallah

Commit Message

docs: update release-notes-0.19.0.md

In this commit, we warn users about the removal
of RPCs `SendToRoute`, `SendToRouteSync`, `SendPayment`,
and `SendPaymentSync` in the next release 0.20.

Pull Request Pull Request #9456: lnrpc+docs: deprecate warning `SendToRoute`, `SendToRouteSync`, `SendPayment`, and `SendPaymentSync` in Release 0.19

Run Details

100634 of 204126 relevant lines covered (49.3%)

1.54 hits per line

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

81.67

/shachain/element.go

package shachain

import (
        "crypto/sha256"
        "errors"

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

// element represents the entity which contains the hash and index
// corresponding to it. An element is the output of the shachain PRF. By
// comparing two indexes we're able to mutate the hash in such way to derive
// another element.
type element struct {
        index index
        hash  chainhash.Hash
}

// newElementFromStr creates new element from the given hash string.
func newElementFromStr(s string, index index) (*element, error) {
        hash, err := hashFromString(s)
        if err != nil {
                return nil, err
        }

        return &element{
                index: index,
                hash:  *hash,
        }, nil
}

// derive computes one shachain element from another by applying a series of
// bit flips and hashing operations based on the starting and ending index.
func (e *element) derive(toIndex index) (*element, error) {
        fromIndex := e.index

        positions, err := fromIndex.deriveBitTransformations(toIndex)
        if err != nil {
                return nil, err
        }

        buf := e.hash.CloneBytes()
        for _, position := range positions {
                // Flip the bit and then hash the current state.
                byteNumber := position / 8
                bitNumber := position % 8

                buf[byteNumber] ^= (1 << bitNumber)

                h := sha256.Sum256(buf)
                buf = h[:]
        }

        hash, err := chainhash.NewHash(buf)
        if err != nil {
                return nil, err
        }

        return &element{
                index: toIndex,
                hash:  *hash,
        }, nil
}

// isEqual returns true if two elements are identical and false otherwise.
func (e *element) isEqual(e2 *element) bool {
        return (e.index == e2.index) &&
                (&e.hash).IsEqual(&e2.hash)
}

const (
        // maxHeight is used to determine the maximum allowable index and the
        // length of the array required to order to derive all previous hashes
        // by index. The entries of this array as also known as buckets.
        maxHeight uint8 = 48

        // rootIndex is an index which corresponds to the root hash.
        rootIndex index = 0
)

// startIndex is the index of first element in the shachain PRF.
var startIndex index = (1 << maxHeight) - 1

// index is a number which identifies the hash number and serves as a way to
// determine the hashing operation required  to derive one hash from another.
// index is initialized with the startIndex and decreases down to zero with
// successive derivations.
type index uint64

// newIndex is used to create index instance. The inner operations with index
// implies that index decreasing from some max number to zero, but for
// simplicity and backward compatibility with previous logic it was transformed
// to work in opposite way.
func newIndex(v uint64) index {
        return startIndex - index(v)
}

// deriveBitTransformations function checks that the 'to' index is derivable
// from the 'from' index by checking the indexes are prefixes of another. The
// bit positions where the zeroes should be changed to ones in order for the
// indexes to become the same are returned. This set of bits is needed in order
// to derive one hash from another.
//
// NOTE: The index 'to' is derivable from index 'from' iff index 'from' lies
// left and above index 'to' on graph below, for example:
// 1. 7(0b111) -> 7
// 2. 6(0b110) -> 6,7
// 3. 5(0b101) -> 5
// 4. 4(0b100) -> 4,5,6,7
// 5. 3(0b011) -> 3
// 6. 2(0b010) -> 2, 3
// 7. 1(0b001) -> 1
//
//          ^ bucket number
//          |
//        3 |   x
//          |   |
//        2 |   |               x
//          |   |               |
//        1 |   |       x       |       x
//          |   |       |       |       |
//        0 |   |   x   |   x   |   x   |   x
//          |   |   |   |   |   |   |   |   |
//          +---|---|---|---|---|---|---|---|---> index
//              0   1   2   3   4   5   6   7
func (from index) deriveBitTransformations(to index) ([]uint8, error) {
        var positions []uint8

        if from == to {
                return positions, nil
        }

        //        + --------------- +
        //         | №  | from | to  |
        //        + -- + ---- + --- +
        //        | 48 |         1  |  1  |
        //        | 47 |         0  |  0  | [48-5] - same part of 'from' and 'to'
        //        | 46 |   0  |  0  |            indexes which also is called prefix.
        //                ....
        //        |  5 |         1  |  1  |
        //        |  4 |         0  |  1  | <--- position after which indexes becomes
        //        |  3 |   0  |  0  |         different, after this position
        //        |  2 |   0  |  1  |         bits in 'from' index all should be
        //        |  1 |   0  |  0  |         zeros or such indexes considered to be
        //        |  0 |   0  |  1  |         not derivable.
        //        + -- + ---- + --- +
        zeros := countTrailingZeros(from)
        if uint64(from) != getPrefix(to, zeros) {
                return nil, errors.New("prefixes are different - indexes " +
                        "aren't derivable")
        }

        // The remaining part of 'to' index represents the positions which we
        // will use then in order to derive one element from another.
        for position := zeros - 1; ; position-- {
                if getBit(to, position) == 1 {
                        positions = append(positions, position)
                }

                if position == 0 {
                        break
                }
        }

        return positions, nil
}

1	package shachain
2
3	import (
4	"crypto/sha256"
5	"errors"
6
7	"github.com/btcsuite/btcd/chaincfg/chainhash"
8	)
9
10	// element represents the entity which contains the hash and index
11	// corresponding to it. An element is the output of the shachain PRF. By
12	// comparing two indexes we're able to mutate the hash in such way to derive
13	// another element.
14	type element struct {
15	index index
16	hash chainhash.Hash
17	}
18
19	// newElementFromStr creates new element from the given hash string.
20	func newElementFromStr(s string, index index) (*element, error) {	×
21	hash, err := hashFromString(s)	×
22	if err != nil {	×
23	return nil, err	×
24	}	×
25
26	return &element{	×
27	index: index,	×
28	hash: *hash,	×
29	}, nil	×
30	}
31
32	// derive computes one shachain element from another by applying a series of
33	// bit flips and hashing operations based on the starting and ending index.
34	func (e element) derive(toIndex index) (element, error) {	3✔
35	fromIndex := e.index	3✔
36		3✔
37	positions, err := fromIndex.deriveBitTransformations(toIndex)	3✔
38	if err != nil {	6✔
39	return nil, err	3✔
40	}	3✔
41
42	buf := e.hash.CloneBytes()	3✔
43	for _, position := range positions {	6✔
44	// Flip the bit and then hash the current state.	3✔
45	byteNumber := position / 8	3✔
46	bitNumber := position % 8	3✔
47		3✔
48	buf[byteNumber] ^= (1 << bitNumber)	3✔
49		3✔
50	h := sha256.Sum256(buf)	3✔
51	buf = h[:]	3✔
52	}	3✔
53
54	hash, err := chainhash.NewHash(buf)	3✔
55	if err != nil {	3✔
56	return nil, err	×
57	}	×
58
59	return &element{	3✔
60	index: toIndex,	3✔
61	hash: *hash,	3✔
62	}, nil	3✔
63	}
64
65	// isEqual returns true if two elements are identical and false otherwise.
66	func (e element) isEqual(e2 element) bool {	3✔
67	return (e.index == e2.index) &&	3✔
68	(&e.hash).IsEqual(&e2.hash)	3✔
69	}	3✔
70
71	const (
72	// maxHeight is used to determine the maximum allowable index and the
73	// length of the array required to order to derive all previous hashes
74	// by index. The entries of this array as also known as buckets.
75	maxHeight uint8 = 48
76
77	// rootIndex is an index which corresponds to the root hash.
78	rootIndex index = 0
79	)
80
81	// startIndex is the index of first element in the shachain PRF.
82	var startIndex index = (1 << maxHeight) - 1
83
84	// index is a number which identifies the hash number and serves as a way to
85	// determine the hashing operation required to derive one hash from another.
86	// index is initialized with the startIndex and decreases down to zero with
87	// successive derivations.
88	type index uint64
89
90	// newIndex is used to create index instance. The inner operations with index
91	// implies that index decreasing from some max number to zero, but for
92	// simplicity and backward compatibility with previous logic it was transformed
93	// to work in opposite way.
94	func newIndex(v uint64) index {	3✔
95	return startIndex - index(v)	3✔
96	}	3✔
97
98	// deriveBitTransformations function checks that the 'to' index is derivable
99	// from the 'from' index by checking the indexes are prefixes of another. The
100	// bit positions where the zeroes should be changed to ones in order for the
101	// indexes to become the same are returned. This set of bits is needed in order
102	// to derive one hash from another.
103	//
104	// NOTE: The index 'to' is derivable from index 'from' iff index 'from' lies
105	// left and above index 'to' on graph below, for example:
106	// 1. 7(0b111) -> 7
107	// 2. 6(0b110) -> 6,7
108	// 3. 5(0b101) -> 5
109	// 4. 4(0b100) -> 4,5,6,7
110	// 5. 3(0b011) -> 3
111	// 6. 2(0b010) -> 2, 3
112	// 7. 1(0b001) -> 1
113	//
114	// ^ bucket number
115	// \|
116	// 3 \| x
117	// \| \|
118	// 2 \| \| x
119	// \| \| \|
120	// 1 \| \| x \| x
121	// \| \| \| \| \|
122	// 0 \| \| x \| x \| x \| x
123	// \| \| \| \| \| \| \| \| \|
124	// +---\|---\|---\|---\|---\|---\|---\|---\|---> index
125	// 0 1 2 3 4 5 6 7
126	func (from index) deriveBitTransformations(to index) ([]uint8, error) {	3✔
127	var positions []uint8	3✔
128		3✔
129	if from == to {	6✔
130	return positions, nil	3✔
131	}	3✔
132
133	// + --------------- +
134	// \| № \| from \| to \|
135	// + -- + ---- + --- +
136	// \| 48 \| 1 \| 1 \|
137	// \| 47 \| 0 \| 0 \| [48-5] - same part of 'from' and 'to'
138	// \| 46 \| 0 \| 0 \| indexes which also is called prefix.
139	// ....
140	// \| 5 \| 1 \| 1 \|
141	// \| 4 \| 0 \| 1 \| <--- position after which indexes becomes
142	// \| 3 \| 0 \| 0 \| different, after this position
143	// \| 2 \| 0 \| 1 \| bits in 'from' index all should be
144	// \| 1 \| 0 \| 0 \| zeros or such indexes considered to be
145	// \| 0 \| 0 \| 1 \| not derivable.
146	// + -- + ---- + --- +
147	zeros := countTrailingZeros(from)	3✔
148	if uint64(from) != getPrefix(to, zeros) {	6✔
149	return nil, errors.New("prefixes are different - indexes " +	3✔
150	"aren't derivable")	3✔
151	}	3✔
152
153	// The remaining part of 'to' index represents the positions which we
154	// will use then in order to derive one element from another.
155	for position := zeros - 1; ; position-- {	6✔
156	if getBit(to, position) == 1 {	6✔
157	positions = append(positions, position)	3✔
158	}	3✔
159
160	if position == 0 {	6✔
161	break	3✔
162	}
163	}
164
165	return positions, nil	3✔
166	}

lightningnetwork / lnd / 13035292482

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