You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
253 lines
4.2 KiB
253 lines
4.2 KiB
package lnwallet_test |
|
|
|
import ( |
|
"reflect" |
|
"testing" |
|
|
|
"github.com/btcsuite/btcd/wire" |
|
"github.com/lightningnetwork/lnd/lnwallet" |
|
) |
|
|
|
type commitSortTest struct { |
|
name string |
|
tx *wire.MsgTx |
|
cltvs []uint32 |
|
intrans map[int]int // input transformation |
|
outtrans map[int]int // output transformation |
|
} |
|
|
|
func (t *commitSortTest) expTxIns() []*wire.TxIn { |
|
if len(t.intrans) == 0 { |
|
return nil |
|
} |
|
|
|
expTxIns := make([]*wire.TxIn, len(t.intrans)) |
|
for start, end := range t.intrans { |
|
expTxIns[end] = t.tx.TxIn[start] |
|
} |
|
|
|
return expTxIns |
|
} |
|
|
|
func (t *commitSortTest) expTxOuts() []*wire.TxOut { |
|
if len(t.outtrans) == 0 { |
|
return nil |
|
} |
|
|
|
expTxOuts := make([]*wire.TxOut, len(t.outtrans)) |
|
for start, end := range t.outtrans { |
|
expTxOuts[end] = t.tx.TxOut[start] |
|
} |
|
|
|
return expTxOuts |
|
} |
|
|
|
var commitSortTests = []commitSortTest{ |
|
{ |
|
name: "sort inputs on prevoutpoint txid", |
|
tx: &wire.MsgTx{ |
|
TxIn: []*wire.TxIn{ |
|
{ |
|
PreviousOutPoint: wire.OutPoint{ |
|
Hash: [32]byte{0x01}, |
|
}, |
|
}, |
|
{ |
|
PreviousOutPoint: wire.OutPoint{ |
|
Hash: [32]byte{0x00}, |
|
}, |
|
}, |
|
}, |
|
}, |
|
intrans: map[int]int{ |
|
0: 1, |
|
1: 0, |
|
}, |
|
}, |
|
{ |
|
name: "sort inputs on prevoutpoint index", |
|
tx: &wire.MsgTx{ |
|
TxIn: []*wire.TxIn{ |
|
{ |
|
PreviousOutPoint: wire.OutPoint{ |
|
Index: 1, |
|
}, |
|
}, |
|
{ |
|
PreviousOutPoint: wire.OutPoint{ |
|
Index: 0, |
|
}, |
|
}, |
|
}, |
|
}, |
|
intrans: map[int]int{ |
|
0: 1, |
|
1: 0, |
|
}, |
|
}, |
|
{ |
|
name: "inputs already sorted", |
|
tx: &wire.MsgTx{ |
|
TxIn: []*wire.TxIn{ |
|
{ |
|
PreviousOutPoint: wire.OutPoint{ |
|
Index: 0, |
|
}, |
|
}, |
|
{ |
|
PreviousOutPoint: wire.OutPoint{ |
|
Index: 1, |
|
}, |
|
}, |
|
}, |
|
}, |
|
intrans: map[int]int{ |
|
0: 0, |
|
1: 1, |
|
}, |
|
}, |
|
{ |
|
name: "sort outputs on value", |
|
tx: &wire.MsgTx{ |
|
TxOut: []*wire.TxOut{ |
|
{ |
|
Value: 2, |
|
PkScript: []byte{0x0}, |
|
}, |
|
{ |
|
Value: 1, |
|
PkScript: []byte{0x0}, |
|
}, |
|
}, |
|
}, |
|
cltvs: []uint32{0, 0}, |
|
outtrans: map[int]int{ |
|
0: 1, |
|
1: 0, |
|
}, |
|
}, |
|
{ |
|
name: "sort outputs on pkscript", |
|
tx: &wire.MsgTx{ |
|
TxOut: []*wire.TxOut{ |
|
{ |
|
Value: 1, |
|
PkScript: []byte{0x2}, |
|
}, |
|
{ |
|
Value: 1, |
|
PkScript: []byte{0x1}, |
|
}, |
|
}, |
|
}, |
|
cltvs: []uint32{0, 0}, |
|
outtrans: map[int]int{ |
|
0: 1, |
|
1: 0, |
|
}, |
|
}, |
|
{ |
|
name: "sort outputs on cltv", |
|
tx: &wire.MsgTx{ |
|
TxOut: []*wire.TxOut{ |
|
{ |
|
Value: 1, |
|
PkScript: []byte{0x1}, |
|
}, |
|
{ |
|
Value: 1, |
|
PkScript: []byte{0x1}, |
|
}, |
|
}, |
|
}, |
|
cltvs: []uint32{2, 1}, |
|
outtrans: map[int]int{ |
|
0: 1, |
|
1: 0, |
|
}, |
|
}, |
|
{ |
|
name: "sort complex outputs", |
|
tx: &wire.MsgTx{ |
|
TxOut: []*wire.TxOut{ |
|
{ |
|
Value: 100000, |
|
PkScript: []byte{0x01, 0x02}, |
|
}, |
|
{ |
|
Value: 200000, |
|
PkScript: []byte{0x03, 0x02}, |
|
}, |
|
{ |
|
Value: 1000, |
|
PkScript: []byte{0x03}, |
|
}, |
|
{ |
|
Value: 1000, |
|
PkScript: []byte{0x02}, |
|
}, |
|
{ |
|
Value: 1000, |
|
PkScript: []byte{0x1}, |
|
}, |
|
{ |
|
Value: 1000, |
|
PkScript: []byte{0x1}, |
|
}, |
|
}, |
|
}, |
|
cltvs: []uint32{0, 0, 100, 90, 70, 80}, |
|
outtrans: map[int]int{ |
|
0: 4, |
|
1: 5, |
|
2: 3, |
|
3: 2, |
|
4: 0, |
|
5: 1, |
|
}, |
|
}, |
|
{ |
|
name: "outputs already sorted", |
|
tx: &wire.MsgTx{ |
|
TxOut: []*wire.TxOut{ |
|
{ |
|
Value: 1, |
|
PkScript: []byte{0x1}, |
|
}, |
|
{ |
|
Value: 1, |
|
PkScript: []byte{0x1}, |
|
}, |
|
}, |
|
}, |
|
cltvs: []uint32{1, 2}, |
|
outtrans: map[int]int{ |
|
0: 0, |
|
1: 1, |
|
}, |
|
}, |
|
} |
|
|
|
// TestCommitSort asserts that the outputs of a transaction are properly sorted |
|
// using InPlaceCommitSort. The outputs should always be sorted by value, then |
|
// lexicographically by pkscript, and then CLTV value. |
|
func TestCommitSort(t *testing.T) { |
|
for _, test := range commitSortTests { |
|
t.Run(test.name, func(t *testing.T) { |
|
expTxIns := test.expTxIns() |
|
expTxOuts := test.expTxOuts() |
|
|
|
lnwallet.InPlaceCommitSort(test.tx, test.cltvs) |
|
|
|
if !reflect.DeepEqual(test.tx.TxIn, expTxIns) { |
|
t.Fatalf("commit inputs mismatch, want: %v, "+ |
|
"got: %v", expTxIns, test.tx.TxIn) |
|
} |
|
|
|
if !reflect.DeepEqual(test.tx.TxOut, expTxOuts) { |
|
t.Fatalf("commit outputs mismatch, want: %v, "+ |
|
"got: %v", expTxOuts, test.tx.TxOut) |
|
} |
|
}) |
|
} |
|
}
|
|
|