refactor: remove unused packages

packages/byteutils/byteutils.go

-package byteutils
-
-func ReadAvailableBytesToBuffer(target []byte, targetOffset int, source []byte, sourceOffset int, sourceLength int) int {
-	availableBytes := sourceLength - sourceOffset
-	requiredBytes := len(target) - targetOffset
-
-	var bytesToRead int
-	if availableBytes < requiredBytes {
-		bytesToRead = availableBytes
-	} else {
-		bytesToRead = requiredBytes
-	}
-
-	copy(target[targetOffset:], source[sourceOffset:sourceOffset+bytesToRead])
-
-	return bytesToRead
-}

packages/crypto/hash20.go

-package crypto
-
-import (
-	"crypto/sha256"
-
-	"golang.org/x/crypto/ripemd160"
-)
-
-func Hash20(input []byte) []byte {
-	sha256Hasher := sha256.New()
-	sha256Hasher.Write(input)
-
-	ripemd160Hasher := ripemd160.New()
-	ripemd160Hasher.Write(sha256Hasher.Sum(nil))
-
-	return ripemd160Hasher.Sum(nil)
-}

packages/iac/area.go

-package iac
-
-import (
-	"math"
-
-	olc "github.com/google/open-location-code/go"
-	"github.com/iotaledger/iota.go/trinary"
-)
-
-type Area struct {
-	olc.CodeArea
-	IACCode trinary.Trytes
-	OLCCode string
-}
-
-func (area *Area) Distance(other *Area) float64 {
-	lat1, lng1 := area.Center()
-	lat2, lng2 := other.Center()
-
-	return distance(lat1, lng1, lat2, lng2)
-}
-
-func distance(lat1, lon1, lat2, lon2 float64) float64 {
-	la1 := lat1 * math.Pi / 180
-	lo1 := lon1 * math.Pi / 180
-	la2 := lat2 * math.Pi / 180
-	lo2 := lon2 * math.Pi / 180
-
-	return 2 * EARTH_RADIUS_IN_METERS * math.Asin(math.Sqrt(hsin(la2-la1)+math.Cos(la1)*math.Cos(la2)*hsin(lo2-lo1)))
-}
-
-func hsin(theta float64) float64 {
-	return math.Pow(math.Sin(theta/2), 2)
-}
-
-const (
-	EARTH_RADIUS_IN_METERS = 6371000
-)

packages/iac/errors.go

-package iac
-
-import "github.com/iotaledger/goshimmer/packages/errors"
-
-var (
-	ErrConversionFailed = errors.New("conversion between IAC and internal OLC format failed")
-	ErrDecodeFailed     = errors.Wrap(errors.New("decoding error"), "failed to decode the IAC")
-)

packages/iac/iac.go

-package iac
-
-import (
-	olc "github.com/google/open-location-code/go"
-	"github.com/iotaledger/goshimmer/packages/errors"
-	"github.com/iotaledger/iota.go/trinary"
-)
-
-func Decode(trytes trinary.Trytes) (result *Area, err errors.IdentifiableError) {
-	if olcCode, conversionErr := OLCCodeFromTrytes(trytes); conversionErr != nil {
-		err = conversionErr
-	} else {
-		if codeArea, olcErr := olc.Decode(olcCode); olcErr == nil {
-			result = &Area{
-				IACCode:  trytes,
-				OLCCode:  olcCode,
-				CodeArea: codeArea,
-			}
-		} else {
-			err = ErrDecodeFailed.Derive(olcErr, "failed to decode the IAC")
-		}
-	}
-
-	return
-}

packages/iac/olc_conversion.go

-package iac
-
-import (
-	"github.com/iotaledger/goshimmer/packages/errors"
-	"github.com/iotaledger/iota.go/trinary"
-)
-
-var (
-	OLC_ALPHABET   = []rune{'2', '3', '4', '5', '6', '7', '8', '9', 'C', 'F', 'G', 'H', 'J', 'M', 'P', 'Q', 'R', 'V', 'W', 'X'}
-	IAC_ALPHABET   = []rune{'F', 'G', 'H', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'X', 'W', 'Y', 'Z'}
-	OLC_TO_IAC_MAP = make(map[rune]rune, 22)
-	IAC_TO_OLC_MAP = make(map[rune]rune, 22)
-)
-
-const (
-	OLC_SEPARATOR = '+'
-	OLC_PADDING   = '0'
-	IAC_SEPARATOR = '9'
-	IAC_PADDING   = 'A'
-)
-
-func init() {
-	for pos, char := range OLC_ALPHABET {
-		OLC_TO_IAC_MAP[char] = IAC_ALPHABET[pos]
-		IAC_TO_OLC_MAP[IAC_ALPHABET[pos]] = char
-	}
-
-	OLC_TO_IAC_MAP[OLC_SEPARATOR] = IAC_SEPARATOR
-	OLC_TO_IAC_MAP[OLC_PADDING] = IAC_PADDING
-	IAC_TO_OLC_MAP[IAC_SEPARATOR] = OLC_SEPARATOR
-	IAC_TO_OLC_MAP[IAC_PADDING] = OLC_PADDING
-}
-
-func TrytesFromOLCCode(code string) (result trinary.Trytes, err errors.IdentifiableError) {
-	for _, char := range code {
-		if translatedChar, exists := OLC_TO_IAC_MAP[char]; exists {
-			result += trinary.Trytes(translatedChar)
-		} else {
-			err = ErrConversionFailed.Derive("invalid character in input")
-		}
-	}
-
-	return
-}
-
-func OLCCodeFromTrytes(trytes trinary.Trytes) (result string, err errors.IdentifiableError) {
-	for _, char := range trytes {
-		if translatedChar, exists := IAC_TO_OLC_MAP[char]; exists {
-			result += string(translatedChar)
-		} else {
-			err = ErrConversionFailed.Derive("invalid character in input")
-		}
-	}
-
-	return
-}

packages/identity/constants.go

-package identity
-
-import "crypto/ed25519"
-
-const (
-	IDENTIFIER_BYTE_LENGTH = 20
-	PUBLIC_KEY_BYTE_LENGTH = ed25519.PublicKeySize
-	SIGNATURE_BYTE_LENGTH  = ed25519.PublicKeySize + ed25519.SignatureSize
-
-	MARSHALED_IDENTITY_PUBLIC_KEY_START  = 0
-	MARSHALED_IDENTITY_PRIVATE_KEY_START = MARSHALED_IDENTITY_PUBLIC_KEY_END
-
-	MARSHALED_IDENTITY_PUBLIC_KEY_SIZE  = PUBLIC_KEY_BYTE_LENGTH
-	MARSHALED_IDENTITY_PRIVATE_KEY_SIZE = ed25519.PrivateKeySize
-
-	MARSHALED_IDENTITY_PUBLIC_KEY_END  = MARSHALED_IDENTITY_PUBLIC_KEY_START + MARSHALED_IDENTITY_PUBLIC_KEY_SIZE
-	MARSHALED_IDENTITY_PRIVATE_KEY_END = MARSHALED_IDENTITY_PRIVATE_KEY_START + MARSHALED_IDENTITY_PRIVATE_KEY_SIZE
-
-	MARSHALED_IDENTITY_TOTAL_SIZE = MARSHALED_IDENTITY_PRIVATE_KEY_END
-)

packages/identity/errors.go

-package identity
-
-import "errors"
-
-var (
-	ErrInvalidDataLen   = errors.New("identity: invalid input data length")
-	ErrInvalidSignature = errors.New("identity: invalid signature")
-)

packages/identity/identity.go

-package identity
-
-import (
-	"crypto/ed25519"
-	"crypto/sha256"
-	"encoding/hex"
-
-	"github.com/iotaledger/goshimmer/packages/autopeering/peer"
-)
-
-type Identity struct {
-	Identifier       peer.ID
-	StringIdentifier string
-	PublicKey        ed25519.PublicKey
-	privateKey       ed25519.PrivateKey
-}
-
-// Creates a new identity based on the given public key.
-func NewPublicIdentity(publicKey ed25519.PublicKey) *Identity {
-	identifier := sha256.Sum256(publicKey)
-
-	return &Identity{
-		Identifier:       identifier,
-		StringIdentifier: hex.EncodeToString(identifier[:8]),
-		PublicKey:        publicKey,
-		privateKey:       nil,
-	}
-}
-
-// Generates a identity based on a newly generated public/private key pair.
-// It will panic if no such pair could be generated.
-func GeneratePrivateIdentity() *Identity {
-	publicKey, privateKey, err := ed25519.GenerateKey(nil)
-	if err != nil {
-		panic("identity: failed generating key: " + err.Error())
-	}
-
-	return newPrivateIdentity(publicKey, privateKey)
-}
-
-// Sign signs the message with privateKey and returns the message plus the signature.
-func (id *Identity) AddSignature(msg []byte) []byte {
-	signatureStart := len(msg)
-
-	signature := ed25519.Sign(id.privateKey, msg)
-
-	data := make([]byte, signatureStart+SIGNATURE_BYTE_LENGTH)
-
-	copy(data[:signatureStart], msg)
-
-	// add public key and signature
-	copy(data[signatureStart:signatureStart+ed25519.PublicKeySize], id.PublicKey)
-	copy(data[signatureStart+ed25519.PublicKeySize:], signature)
-
-	return data
-}
-
-// Verifies whether the data contains a valid signature of the message.
-func (id *Identity) VerifySignature(data []byte) error {
-	signatureStart := len(data) - SIGNATURE_BYTE_LENGTH
-	if signatureStart <= 0 {
-		return ErrInvalidDataLen
-	}
-
-	msg := data[:signatureStart]
-
-	// ignore the public key
-	sig := data[signatureStart+ed25519.PublicKeySize:]
-
-	if !ed25519.Verify(id.PublicKey, msg, sig) {
-		return ErrInvalidSignature
-	}
-
-	return nil
-}
-
-// Returns the identitiy derived from the signed message.
-func FromSignedData(data []byte) (*Identity, error) {
-	signatureStart := len(data) - SIGNATURE_BYTE_LENGTH
-	if signatureStart <= 0 {
-		return nil, ErrInvalidDataLen
-	}
-
-	pubKey := data[signatureStart : signatureStart+ed25519.PublicKeySize]
-
-	identity := NewPublicIdentity(pubKey)
-	if err := identity.VerifySignature(data); err != nil {
-		return nil, err
-	}
-
-	return identity, nil
-}
-
-func (id *Identity) Marshal() []byte {
-	data := make([]byte, MARSHALED_IDENTITY_TOTAL_SIZE)
-
-	copy(data[MARSHALED_IDENTITY_PUBLIC_KEY_START:MARSHALED_IDENTITY_PUBLIC_KEY_END], id.PublicKey)
-	copy(data[MARSHALED_IDENTITY_PRIVATE_KEY_START:MARSHALED_IDENTITY_PRIVATE_KEY_END], id.privateKey)
-
-	return data
-}
-
-func Unmarshal(data []byte) (*Identity, error) {
-	if len(data) != MARSHALED_IDENTITY_TOTAL_SIZE {
-		return nil, ErrInvalidDataLen
-	}
-
-	publicKey := data[MARSHALED_IDENTITY_PUBLIC_KEY_START:MARSHALED_IDENTITY_PUBLIC_KEY_END]
-	privateKey := data[MARSHALED_IDENTITY_PRIVATE_KEY_START:MARSHALED_IDENTITY_PRIVATE_KEY_END]
-
-	return newPrivateIdentity(publicKey, privateKey), nil
-}
-
-func newPrivateIdentity(publicKey []byte, privateKey []byte) *Identity {
-
-	identity := NewPublicIdentity(publicKey)
-	identity.privateKey = privateKey
-
-	return identity
-}

packages/identity/types.go

-package identity
-
-type IdentityType int

packages/network/udp/events.go

-package udp
-
-import (
-	"net"
-
-	"github.com/iotaledger/hive.go/events"
-)
-
-type serverEvents struct {
-	Start       *events.Event
-	Shutdown    *events.Event
-	ReceiveData *events.Event
-	Error       *events.Event
-}
-
-func dataCaller(handler interface{}, params ...interface{}) {
-	handler.(func(*net.UDPAddr, []byte))(params[0].(*net.UDPAddr), params[1].([]byte))
-}

packages/network/udp/server.go

-package udp
-
-import (
-	"net"
-	"strconv"
-	"sync"
-
-	"github.com/iotaledger/hive.go/events"
-)
-
-type Server struct {
-	socket            net.PacketConn
-	socketMutex       sync.RWMutex
-	ReceiveBufferSize int
-	Events            serverEvents
-}
-
-func (this *Server) GetSocket() net.PacketConn {
-	this.socketMutex.RLock()
-	defer this.socketMutex.RUnlock()
-	return this.socket
-}
-
-func (this *Server) Shutdown() {
-	this.socketMutex.Lock()
-	defer this.socketMutex.Unlock()
-	if this.socket != nil {
-		socket := this.socket
-		this.socket = nil
-
-		socket.Close()
-	}
-}
-
-func (this *Server) Listen(address string, port int) {
-	if socket, err := net.ListenPacket("udp", address+":"+strconv.Itoa(port)); err != nil {
-		this.Events.Error.Trigger(err)
-
-		return
-	} else {
-		this.socketMutex.Lock()
-		this.socket = socket
-		this.socketMutex.Unlock()
-	}
-
-	this.Events.Start.Trigger()
-	defer this.Events.Shutdown.Trigger()
-
-	buf := make([]byte, this.ReceiveBufferSize)
-	for this.GetSocket() != nil {
-		if bytesRead, addr, err := this.GetSocket().ReadFrom(buf); err != nil {
-			if this.GetSocket() != nil {
-				this.Events.Error.Trigger(err)
-			}
-		} else {
-			this.Events.ReceiveData.Trigger(addr.(*net.UDPAddr), buf[:bytesRead])
-		}
-	}
-}
-
-func NewServer(receiveBufferSize int) *Server {
-	return &Server{
-		ReceiveBufferSize: receiveBufferSize,
-		Events: serverEvents{
-			Start:       events.NewEvent(events.CallbackCaller),
-			Shutdown:    events.NewEvent(events.CallbackCaller),
-			ReceiveData: events.NewEvent(dataCaller),
-			Error:       events.NewEvent(events.ErrorCaller),
-		},
-	}
-}

packages/network/udp/types.go

-package udp
-
-import "net"
-
-type Callback = func()
-
-type AddressDataConsumer = func(addr *net.UDPAddr, data []byte)
-
-type ErrorConsumer = func(err error)