swarm

package
v2.3.0-rc5 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Nov 5, 2024 License: BSD-3-Clause Imports: 12 Imported by: 45

Documentation

Overview

Package swarm contains most basic and general Swarm concepts.

Index

Constants

View Source 
const (
	StampIndexSize           = 8 // TODO: use this size in related code.
	StampTimestampSize       = 8 // TODO: use this size in related code.
	SpanSize                 = 8
	SectionSize              = 32
	Branches                 = 128
	EncryptedBranches        = Branches / 2
	BmtBranches              = 128
	ChunkSize                = SectionSize * Branches
	HashSize                 = 32
	MaxPO              uint8 = 31
	ExtendedPO         uint8 = MaxPO + 5
	MaxBins                  = MaxPO + 1
	ChunkWithSpanSize        = ChunkSize + SpanSize
	SocSignatureSize         = 65
	SocMinChunkSize          = HashSize + SocSignatureSize + SpanSize
	SocMaxChunkSize          = SocMinChunkSize + ChunkSize
)

Variables

View Source 
var (
	// EmptyAddress is the address that is all zeroes.
	EmptyAddress = NewAddress(make([]byte, HashSize))
	// ZeroAddress is the address that has no value.
	ZeroAddress = NewAddress(nil)
)
View Source 
var (
	ErrInvalidChunk = errors.New("invalid chunk")
)
View Source 
var (
	// Ethereum Address for SOC owner of Dispersed Replicas
	// generated from private key 0x0100000000000000000000000000000000000000000000000000000000000000
	ReplicasOwner, _ = hex.DecodeString("dc5b20847f43d67928f49cd4f85d696b5a7617b5")
)

Functions

func ContainsAddress 

func ContainsAddress(addrs []Address, a Address) bool

ContainsAddress reports whether a is present in addrs.

func ContainsChunkWithAddress 

func ContainsChunkWithAddress(chunks []Chunk, a Address) bool

ContainsChunkWithAddress reports whether Chunk with Address a is present in chunks.

func ContainsChunkWithData 

func ContainsChunkWithData(chunks []Chunk, d []byte) bool

ContainsChunkWithAddress reports whether Chunk with data d is present in chunks.

func Distance 

func Distance(x, y Address) (*big.Int, error)

Distance returns the distance between address x and address y as a (comparable) big integer using the distance metric defined in the swarm specification. Fails if not all addresses are of equal length.

func DistanceCmp 

func DistanceCmp(a, x, y Address) (int, error)

DistanceCmp compares x and y to a in terms of the distance metric defined in the swarm specification. it returns:

  • 1 if x is closer to a than y
  • 0 if x and y are equally far apart from a (this means that x and y are the same address)
  • -1 if x is farther from a than y

Fails if not all addresses are of equal length.

func DistanceRaw 

func DistanceRaw(x, y Address) ([]byte, error)

DistanceRaw returns the distance between address x and address y in big-endian binary format using the distance metric defined in the swarm specification. Fails if not all addresses are of equal length.

func ExtendedProximity 

func ExtendedProximity(one, other []byte) (ret uint8)

func IndexOfAddress 

func IndexOfAddress(addrs []Address, a Address) int

IndexOfAddress returns the index of the first occurrence of a in addrs, or -1 if not present.

func IndexOfChunkWithAddress 

func IndexOfChunkWithAddress(chunks []Chunk, a Address) int

IndexOfChunkWithAddress returns the index of the first occurrence of Chunk with Address a in chunks, or -1 if not present.

func NewHasher 

func NewHasher() hash.Hash

NewHasher returns new Keccak-256 hasher.

func NewPrefixHasher 

func NewPrefixHasher(prefix []byte) hash.Hash

NewPrefixHasher returns new hasher which is Keccak-256 hasher with prefix value added as initial data.

func Proximity 

func Proximity(one, other []byte) (ret uint8)

Proximity returns the proximity order of the MSB distance between x and y

The distance metric MSB(x, y) of two equal length byte sequences x an y is the value of the binary integer cast of the x^y, ie., x and y bitwise xor-ed. the binary cast is big endian: most significant bit first (=MSB).

Proximity(x, y) is a discrete logarithmic scaling of the MSB distance. It is defined as the reverse rank of the integer part of the base 2 logarithm of the distance. It is calculated by counting the number of common leading zeros in the (MSB) binary representation of the x^y.

(0 farthest, 255 closest, 256 self)

func RandBatchID 

func RandBatchID(tb testing.TB) []byte

RandBatchID generates a random BatchID.

Types

type Address 

type Address struct {
	// contains filtered or unexported fields
}

Address represents an address in Swarm metric space of Node and Chunk addresses.

func MustParseHexAddress 

func MustParseHexAddress(s string) Address

MustParseHexAddress returns an Address from a hex-encoded string representation, and panics if there is a parse error.

func NewAddress 

func NewAddress(b []byte) Address

NewAddress constructs Address from a byte slice.

func ParseBitStrAddress 

func ParseBitStrAddress(src string) (Address, error)

ParseBitStrAddress parses overlay addresses in binary format (eg: 111101101) to it's corresponding overlay address.

func ParseHexAddress 

func ParseHexAddress(s string) (a Address, err error)

ParseHexAddress returns an Address from a hex-encoded string representation.

func RandAddress 

func RandAddress(tb testing.TB) Address

RandAddress generates a random address.

func RandAddressAt 

func RandAddressAt(tb testing.TB, self Address, prox int) Address

RandAddressAt generates a random address at proximity order prox relative to address.

func RandAddresses 

func RandAddresses(tb testing.TB, count int) []Address

RandAddresses generates slice with a random address.

func RemoveAddress 

func RemoveAddress(addrs []Address, a Address) []Address

RemoveAddress removes first occurrence of a in addrs, returning the modified slice.

func (Address) ByteString 

func (a Address) ByteString() string

ByteString returns raw Address string without encoding.

func (Address) Bytes 

func (a Address) Bytes() []byte

Bytes returns bytes representation of the Address.

func (Address) Clone 

func (a Address) Clone() Address

Clone returns a new swarm address which is a copy of this one.

func (Address) Closer 

func (x Address) Closer(a Address, y Address) (bool, error)

Closer returns if x is closer to a than y

func (Address) Compare 

func (a Address) Compare(b Address) int

Compare returns an integer comparing two addresses lexicographically. The result will be 0 if a == b, -1 if a < b, and +1 if a > b.

func (Address) Equal 

func (a Address) Equal(b Address) bool

Equal returns true if two addresses are identical.

func (Address) IsEmpty 

func (a Address) IsEmpty() bool

IsEmpty returns true if the Address is all zeroes.

func (Address) IsValidLength 

func (a Address) IsValidLength() bool

IsValidLength returns true if the Address is of valid length.

func (Address) IsValidNonEmpty 

func (a Address) IsValidNonEmpty() bool

IsValidNonEmpty returns true if the Address has valid length and is not empty.

func (Address) IsZero 

func (a Address) IsZero() bool

IsZero returns true if the Address is not set to any value.

func (Address) MarshalJSON 

func (a Address) MarshalJSON() ([]byte, error)

MarshalJSON returns JSON-encoded representation of Address.

func (Address) MemberOf 

func (a Address) MemberOf(addrs []Address) bool

MemberOf returns true if the address is a member of the provided set.

func (Address) String 

func (a Address) String() string

String returns a hex-encoded representation of the Address.

func (*Address) UnmarshalJSON 

func (a *Address) UnmarshalJSON(b []byte) (err error)

UnmarshalJSON sets Address to a value from JSON-encoded representation.

type AddressIterFunc 

type AddressIterFunc func(address Address) error

AddressIterFunc is a callback on every address that is found by the iterator.

type Chunk 

type Chunk interface {
	// Address returns the chunk address.
	Address() Address
	// Data returns the chunk data.
	Data() []byte
	// TagID returns the tag ID for this chunk.
	TagID() uint32
	// WithTagID attaches the tag ID to the chunk.
	WithTagID(t uint32) Chunk
	// Stamp returns the postage stamp associated with this chunk.
	Stamp() Stamp
	// WithStamp attaches a postage stamp to the chunk.
	WithStamp(Stamp) Chunk
	// Depth returns the batch depth of the stamp - allowed batch size = 2^{depth}.
	Depth() uint8
	// BucketDepth returns the bucket depth of the batch of the stamp - always < depth.
	BucketDepth() uint8
	// Immutable returns whether the batch is immutable
	Immutable() bool
	// WithBatch attaches batch parameters to the chunk.
	WithBatch(depth, bucketDepth uint8, immutable bool) Chunk
	// Equal checks if the chunk is equal to another.
	Equal(Chunk) bool
}

func NewChunk 

func NewChunk(addr Address, data []byte) Chunk

type ChunkType 

type ChunkType uint8

ChunkType indicates different categories of chunks. 

const (
	ChunkTypeUnspecified ChunkType = iota
	ChunkTypeContentAddressed
	ChunkTypeSingleOwner
)

DO NOT CHANGE ORDER

func (ChunkType) String 

func (ct ChunkType) String() string

String implements Stringer interface.

type Neighborhood 

type Neighborhood struct {
	// contains filtered or unexported fields
}

func NewNeighborhood 

func NewNeighborhood(a Address, bits uint8) Neighborhood

func (Neighborhood) Bytes 

func (n Neighborhood) Bytes() []byte

Bytes returns bytes representation of the Neighborhood.

func (Neighborhood) Clone 

func (n Neighborhood) Clone() Neighborhood

Bytes returns bytes representation of the Neighborhood.

func (Neighborhood) Equal 

func (n Neighborhood) Equal(b Neighborhood) bool

Equal returns true if two neighborhoods are identical.

func (Neighborhood) String 

func (n Neighborhood) String() string

String returns a bit string of the Neighborhood.

type PrefixHasher 

type PrefixHasher struct {
	hash.Hash
	// contains filtered or unexported fields
}

func (*PrefixHasher) Reset 

func (h *PrefixHasher) Reset()

type Stamp 

type Stamp interface {
	BatchID() []byte
	Index() []byte
	Sig() []byte
	Timestamp() []byte
	Clone() Stamp
	Hash() ([]byte, error)
	encoding.BinaryMarshaler
	encoding.BinaryUnmarshaler
}

Stamp interface for postage.Stamp to avoid circular dependency

func FindStampWithBatchID 

func FindStampWithBatchID(stamps []Stamp, batchID []byte) (Stamp, bool)

FindStampWithBatchID returns the first occurrence of Stamp having the same batchID.

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.