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.
71 lines
1.6 KiB
Go
71 lines
1.6 KiB
Go
// Copyright (C) 2019-2025, Lux Industries Inc. All rights reserved.
|
|
// See the file LICENSE for licensing terms.
|
|
|
|
package bloom
|
|
|
|
import (
|
|
"errors"
|
|
|
|
"github.com/luxfi/node/utils/bloom"
|
|
)
|
|
|
|
const bytesPerHash = 8
|
|
|
|
var (
|
|
_ Filter = (*filter)(nil)
|
|
|
|
errMaxBytes = errors.New("too large")
|
|
)
|
|
|
|
type Filter interface {
|
|
// Add adds to filter, assumed thread safe
|
|
Add(...[]byte)
|
|
|
|
// Check checks filter, assumed thread safe
|
|
Check([]byte) bool
|
|
}
|
|
|
|
func New(maxN int, p float64, maxBytes int) (Filter, error) {
|
|
numHashes, numEntries := bloom.OptimalParameters(maxN, p)
|
|
// numEntries alone is compared first: bloom.OptimalEntries saturates at
|
|
// math.MaxInt, and forming the byte total from it wraps negative, which
|
|
// clears the cap and hands math.MaxInt to make([]byte, ...). Once
|
|
// numEntries is within maxBytes the sum cannot overflow (numHashes is
|
|
// capped at 16).
|
|
if numEntries > maxBytes || 1+numHashes*bytesPerHash+numEntries > maxBytes {
|
|
return nil, errMaxBytes
|
|
}
|
|
// Use the bloom filter struct directly
|
|
f, err := bloom.New(numHashes, numEntries)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &filter{
|
|
filter: f,
|
|
}, nil
|
|
}
|
|
|
|
type filter struct {
|
|
filter *bloom.Filter
|
|
}
|
|
|
|
func (f *filter) Add(bl ...[]byte) {
|
|
// The bloom.Filter.Add method takes a uint64 hash, not raw bytes
|
|
// We need to hash the bytes first
|
|
for _, b := range bl {
|
|
if len(b) > 0 {
|
|
hash := bloom.Hash(b, nil)
|
|
f.filter.Add(hash)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (f *filter) Check(b []byte) bool {
|
|
// Similarly, Contains takes a uint64 hash
|
|
if len(b) == 0 {
|
|
return false
|
|
}
|
|
hash := bloom.Hash(b, nil)
|
|
return f.filter.Contains(hash)
|
|
}
|