mirror of
https://gitlab.com/pulsechaincom/erigon-pulse.git
synced 2024-12-25 04:57:17 +00:00
1636d9574b
* swarm/pot: refactored pot.remove(), updated comments * swarm/pot: comments updated
211 lines
5.1 KiB
Go
211 lines
5.1 KiB
Go
// Copyright 2017 The go-ethereum Authors
|
|
// This file is part of the go-ethereum library.
|
|
//
|
|
// The go-ethereum library is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Lesser General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// The go-ethereum library is distributed in the hope that it will be useful,
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Lesser General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public License
|
|
// along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
// Package pot see doc.go
|
|
package pot
|
|
|
|
import (
|
|
"encoding/binary"
|
|
"fmt"
|
|
"math/rand"
|
|
"strconv"
|
|
"strings"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
)
|
|
|
|
var (
|
|
zerosBin = Address{}.Bin()
|
|
)
|
|
|
|
// Address is an alias for common.Hash
|
|
type Address common.Hash
|
|
|
|
// NewAddressFromBytes constructs an Address from a byte slice
|
|
func NewAddressFromBytes(b []byte) Address {
|
|
h := common.Hash{}
|
|
copy(h[:], b)
|
|
return Address(h)
|
|
}
|
|
|
|
func (a Address) String() string {
|
|
return fmt.Sprintf("%x", a[:])
|
|
}
|
|
|
|
// MarshalJSON Address serialisation
|
|
func (a *Address) MarshalJSON() (out []byte, err error) {
|
|
return []byte(`"` + a.String() + `"`), nil
|
|
}
|
|
|
|
// UnmarshalJSON Address deserialisation
|
|
func (a *Address) UnmarshalJSON(value []byte) error {
|
|
*a = Address(common.HexToHash(string(value[1 : len(value)-1])))
|
|
return nil
|
|
}
|
|
|
|
// Bin returns the string form of the binary representation of an address (only first 8 bits)
|
|
func (a Address) Bin() string {
|
|
return ToBin(a[:])
|
|
}
|
|
|
|
// ToBin converts a byteslice to the string binary representation
|
|
func ToBin(a []byte) string {
|
|
var bs []string
|
|
for _, b := range a {
|
|
bs = append(bs, fmt.Sprintf("%08b", b))
|
|
}
|
|
return strings.Join(bs, "")
|
|
}
|
|
|
|
// Bytes returns the Address as a byte slice
|
|
func (a Address) Bytes() []byte {
|
|
return a[:]
|
|
}
|
|
|
|
// ProxCmp compares the distances a->target and b->target.
|
|
// Returns -1 if a is closer to target, 1 if b is closer to target
|
|
// and 0 if they are equal.
|
|
func ProxCmp(a, x, y interface{}) int {
|
|
return proxCmp(ToBytes(a), ToBytes(x), ToBytes(y))
|
|
}
|
|
|
|
func proxCmp(a, x, y []byte) int {
|
|
for i := range a {
|
|
dx := x[i] ^ a[i]
|
|
dy := y[i] ^ a[i]
|
|
if dx > dy {
|
|
return 1
|
|
} else if dx < dy {
|
|
return -1
|
|
}
|
|
}
|
|
return 0
|
|
}
|
|
|
|
// RandomAddressAt (address, prox) generates a random address
|
|
// at proximity order prox relative to address
|
|
// if prox is negative a random address is generated
|
|
func RandomAddressAt(self Address, prox int) (addr Address) {
|
|
addr = self
|
|
pos := -1
|
|
if prox >= 0 {
|
|
pos = prox / 8
|
|
trans := prox % 8
|
|
transbytea := byte(0)
|
|
for j := 0; j <= trans; j++ {
|
|
transbytea |= 1 << uint8(7-j)
|
|
}
|
|
flipbyte := byte(1 << uint8(7-trans))
|
|
transbyteb := transbytea ^ byte(255)
|
|
randbyte := byte(rand.Intn(255))
|
|
addr[pos] = ((addr[pos] & transbytea) ^ flipbyte) | randbyte&transbyteb
|
|
}
|
|
for i := pos + 1; i < len(addr); i++ {
|
|
addr[i] = byte(rand.Intn(255))
|
|
}
|
|
|
|
return
|
|
}
|
|
|
|
// RandomAddress generates a random address
|
|
func RandomAddress() Address {
|
|
return RandomAddressAt(Address{}, -1)
|
|
}
|
|
|
|
// NewAddressFromString creates a byte slice from a string in binary representation
|
|
func NewAddressFromString(s string) []byte {
|
|
ha := [32]byte{}
|
|
|
|
t := s + zerosBin[:len(zerosBin)-len(s)]
|
|
for i := 0; i < 4; i++ {
|
|
n, err := strconv.ParseUint(t[i*64:(i+1)*64], 2, 64)
|
|
if err != nil {
|
|
panic("wrong format: " + err.Error())
|
|
}
|
|
binary.BigEndian.PutUint64(ha[i*8:(i+1)*8], n)
|
|
}
|
|
return ha[:]
|
|
}
|
|
|
|
// BytesAddress is an interface for elements addressable by a byte slice
|
|
type BytesAddress interface {
|
|
Address() []byte
|
|
}
|
|
|
|
// ToBytes turns the Val into bytes
|
|
func ToBytes(v Val) []byte {
|
|
if v == nil {
|
|
return nil
|
|
}
|
|
b, ok := v.([]byte)
|
|
if !ok {
|
|
ba, ok := v.(BytesAddress)
|
|
if !ok {
|
|
panic(fmt.Sprintf("unsupported value type %T", v))
|
|
}
|
|
b = ba.Address()
|
|
}
|
|
return b
|
|
}
|
|
|
|
// DefaultPof returns a proximity order comparison operator function
|
|
func DefaultPof(max int) func(one, other Val, pos int) (int, bool) {
|
|
return func(one, other Val, pos int) (int, bool) {
|
|
po, eq := proximityOrder(ToBytes(one), ToBytes(other), pos)
|
|
if po >= max {
|
|
eq = true
|
|
po = max
|
|
}
|
|
return po, eq
|
|
}
|
|
}
|
|
|
|
// proximityOrder returns two parameters:
|
|
// 1. relative proximity order of the arguments one & other;
|
|
// 2. boolean indicating whether the full match occurred (one == other).
|
|
func proximityOrder(one, other []byte, pos int) (int, bool) {
|
|
for i := pos / 8; i < len(one); i++ {
|
|
if one[i] == other[i] {
|
|
continue
|
|
}
|
|
oxo := one[i] ^ other[i]
|
|
start := 0
|
|
if i == pos/8 {
|
|
start = pos % 8
|
|
}
|
|
for j := start; j < 8; j++ {
|
|
if (oxo>>uint8(7-j))&0x01 != 0 {
|
|
return i*8 + j, false
|
|
}
|
|
}
|
|
}
|
|
return len(one) * 8, true
|
|
}
|
|
|
|
// Label displays the node's key in binary format
|
|
func Label(v Val) string {
|
|
if v == nil {
|
|
return "<nil>"
|
|
}
|
|
if s, ok := v.(fmt.Stringer); ok {
|
|
return s.String()
|
|
}
|
|
if b, ok := v.([]byte); ok {
|
|
return ToBin(b)
|
|
}
|
|
panic(fmt.Sprintf("unsupported value type %T", v))
|
|
}
|