mirror of
https://github.com/luxfi/node.git
synced 2026-10-30 15:24:05 +00:00
zeekay
7cf87b230b
The module already called itself github.com/luxfi/node while containing no node in Go: cmd/luxd was twenty-one lines that printed the size of a few types, and the Go column of the matrix measured a VM plugin. A repo that fetches the thing it claims to be has not replaced it, so the Go sources move in — 1515 files, the daemon and everything under it — and the build reaches outside this module for nothing. Rust and C++ sit beside it unchanged and are still measured against it by the differential. That is the point of one repo: the reference implementation and the two ports are the same checkout, so parity is a thing you can run rather than a thing you assert. Verified: builds, and the closure carries no lux-private — checked at build time rather than believed. The daemon starts twelve chains on a local network (P X C Q Z A B G K M F, plus D through its plugin) and reports healthy.
284 lines
6.0 KiB
Go
284 lines
6.0 KiB
Go
// Copyright (C) 2019-2025, Lux Industries Inc. All rights reserved.
|
|
// See the file LICENSE for licensing terms.
|
|
|
|
package predicate
|
|
|
|
import (
|
|
"bytes"
|
|
"testing"
|
|
|
|
"github.com/luxfi/geth/common"
|
|
"github.com/luxfi/geth/core/types"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/luxfi/math/set"
|
|
)
|
|
|
|
func TestNew(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
input []byte
|
|
want Predicate
|
|
}{
|
|
{
|
|
name: "empty_predicate",
|
|
input: nil,
|
|
want: Predicate{
|
|
{delimiter},
|
|
},
|
|
},
|
|
{
|
|
name: "single_byte",
|
|
input: []byte{0x42},
|
|
want: Predicate{
|
|
{0x42, delimiter},
|
|
},
|
|
},
|
|
{
|
|
name: "31_bytes",
|
|
input: make([]byte, 31),
|
|
want: Predicate{
|
|
{31: delimiter},
|
|
},
|
|
},
|
|
{
|
|
name: "32_bytes",
|
|
input: make([]byte, 32),
|
|
want: Predicate{
|
|
{},
|
|
{delimiter},
|
|
},
|
|
},
|
|
{
|
|
name: "40_bytes",
|
|
input: []byte{
|
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
|
|
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
|
|
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
|
|
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
|
|
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
|
|
},
|
|
want: Predicate{
|
|
{
|
|
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
|
|
0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17,
|
|
0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27,
|
|
0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37,
|
|
},
|
|
{
|
|
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47,
|
|
delimiter,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
got := New(test.input)
|
|
require.Equal(t, test.want, got)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestPredicateBytes(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
input Predicate
|
|
want []byte
|
|
wantErr error
|
|
}{
|
|
// Valid test cases
|
|
{
|
|
name: "empty_input",
|
|
input: New(nil),
|
|
want: []byte{},
|
|
wantErr: nil,
|
|
},
|
|
{
|
|
name: "single_byte",
|
|
input: New([]byte{0xbb}),
|
|
want: []byte{0xbb},
|
|
wantErr: nil,
|
|
},
|
|
{
|
|
name: "31_bytes",
|
|
input: New(bytes.Repeat([]byte{0xaa}, 31)),
|
|
want: bytes.Repeat([]byte{0xaa}, 31),
|
|
wantErr: nil,
|
|
},
|
|
{
|
|
name: "32_bytes",
|
|
input: New(bytes.Repeat([]byte{0xdd}, 32)),
|
|
want: bytes.Repeat([]byte{0xdd}, 32),
|
|
wantErr: nil,
|
|
},
|
|
{
|
|
name: "33_bytes",
|
|
input: New(bytes.Repeat([]byte{0xcc}, 33)),
|
|
want: bytes.Repeat([]byte{0xcc}, 33),
|
|
wantErr: nil,
|
|
},
|
|
{
|
|
name: "48_bytes",
|
|
input: New(bytes.Repeat([]byte{0x00}, 48)),
|
|
want: bytes.Repeat([]byte{0x00}, 48),
|
|
wantErr: nil,
|
|
},
|
|
{
|
|
name: "63_bytes",
|
|
input: New(bytes.Repeat([]byte{0xdd}, 63)),
|
|
want: bytes.Repeat([]byte{0xdd}, 63),
|
|
wantErr: nil,
|
|
},
|
|
{
|
|
name: "64_bytes",
|
|
input: New(bytes.Repeat([]byte{0x33}, 64)),
|
|
want: bytes.Repeat([]byte{0x33}, 64),
|
|
wantErr: nil,
|
|
},
|
|
{
|
|
name: "65_bytes",
|
|
input: New(bytes.Repeat([]byte{0xdd}, 65)),
|
|
want: bytes.Repeat([]byte{0xdd}, 65),
|
|
wantErr: nil,
|
|
},
|
|
// Invalid test cases
|
|
{
|
|
name: "all_zeros_empty",
|
|
input: nil,
|
|
want: nil,
|
|
wantErr: errMissingDelimiter,
|
|
},
|
|
{
|
|
name: "all_zeros",
|
|
input: Predicate{{}},
|
|
want: nil,
|
|
wantErr: errMissingDelimiter,
|
|
},
|
|
{
|
|
name: "wrong_delimiter",
|
|
input: Predicate{{0x42}},
|
|
want: nil,
|
|
wantErr: errWrongDelimiter,
|
|
},
|
|
{
|
|
name: "wrong_delimiter",
|
|
input: Predicate{{delimiter}, {}},
|
|
want: nil,
|
|
wantErr: errExcessPadding,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
require := require.New(t)
|
|
|
|
unpacked, err := tt.input.Bytes()
|
|
require.ErrorIs(err, tt.wantErr)
|
|
require.Equal(tt.want, unpacked)
|
|
})
|
|
}
|
|
}
|
|
|
|
func FuzzNewBytesEqual(f *testing.F) {
|
|
f.Fuzz(func(t *testing.T, input []byte) {
|
|
packed := New(input)
|
|
unpacked, err := packed.Bytes()
|
|
require.NoError(t, err)
|
|
require.Equal(t, input, unpacked)
|
|
})
|
|
}
|
|
|
|
func FuzzBytesNewEqual(f *testing.F) {
|
|
f.Fuzz(func(t *testing.T, original []byte) {
|
|
var predicate Predicate
|
|
for i := 0; i < len(original); i += common.HashLength {
|
|
var key common.Hash
|
|
copy(key[:], original[i:])
|
|
predicate = append(predicate, key)
|
|
}
|
|
|
|
unpacked, err := predicate.Bytes()
|
|
if err != nil {
|
|
t.Skip("invalid predicate")
|
|
}
|
|
|
|
repacked := New(unpacked)
|
|
require.Equal(t, predicate, repacked)
|
|
})
|
|
}
|
|
|
|
type allowSet set.Set[common.Address]
|
|
|
|
func (a allowSet) HasPredicate(addr common.Address) bool {
|
|
_, ok := a[addr]
|
|
return ok
|
|
}
|
|
|
|
func TestFromAccessList(t *testing.T) {
|
|
addrA := common.Address{0xAA}
|
|
addrB := common.Address{0xBB}
|
|
addrC := common.Address{0xCC}
|
|
|
|
h1 := common.Hash{1}
|
|
h2 := common.Hash{2}
|
|
h3 := common.Hash{3}
|
|
h4 := common.Hash{4}
|
|
|
|
tests := []struct {
|
|
name string
|
|
rules set.Set[common.Address]
|
|
list types.AccessList
|
|
want map[common.Address][]Predicate
|
|
}{
|
|
{
|
|
name: "empty_list",
|
|
rules: set.Of(addrA),
|
|
list: types.AccessList{},
|
|
want: map[common.Address][]Predicate{},
|
|
},
|
|
{
|
|
name: "no_allowed_addresses",
|
|
rules: set.Of(addrB),
|
|
list: types.AccessList{{Address: addrA, StorageKeys: []common.Hash{h1}}},
|
|
want: map[common.Address][]Predicate{},
|
|
},
|
|
{
|
|
name: "single_tuple_allowed",
|
|
rules: set.Of(addrA),
|
|
list: types.AccessList{{Address: addrA, StorageKeys: []common.Hash{h1, h2}}},
|
|
want: map[common.Address][]Predicate{addrA: {{h1, h2}}},
|
|
},
|
|
{
|
|
name: "repeated_address_accumulates",
|
|
rules: set.Of(addrA),
|
|
list: types.AccessList{
|
|
{Address: addrA, StorageKeys: []common.Hash{h1, h2}},
|
|
{Address: addrA, StorageKeys: []common.Hash{h3}},
|
|
},
|
|
want: map[common.Address][]Predicate{addrA: {{h1, h2}, {h3}}},
|
|
},
|
|
{
|
|
name: "mixed_addresses_filtered",
|
|
rules: set.Of(addrA, addrC),
|
|
list: types.AccessList{
|
|
{Address: addrA, StorageKeys: []common.Hash{h1}},
|
|
{Address: addrB, StorageKeys: []common.Hash{h2}},
|
|
{Address: addrC, StorageKeys: []common.Hash{h3, h4}},
|
|
},
|
|
want: map[common.Address][]Predicate{
|
|
addrA: {{h1}},
|
|
addrC: {{h3, h4}},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tc := range tests {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
req := require.New(t)
|
|
got := FromAccessList(allowSet(tc.rules), tc.list)
|
|
req.Equal(tc.want, got)
|
|
})
|
|
}
|
|
}
|