diff --git a/packages/byteutils/byteutils.go b/packages/byteutils/byteutils.go
deleted file mode 100644
index 1f5311f07d9b2240b7267e26fda45a9a69ac20eb..0000000000000000000000000000000000000000
--- a/packages/byteutils/byteutils.go
+++ /dev/null
@@ -1,17 +0,0 @@
-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
-}
diff --git a/packages/crypto/hash20.go b/packages/crypto/hash20.go
deleted file mode 100644
index d27ef21a2b30e433a6a6b5f2dc58b57d434efbe8..0000000000000000000000000000000000000000
--- a/packages/crypto/hash20.go
+++ /dev/null
@@ -1,17 +0,0 @@
-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)
-}
diff --git a/packages/iac/area.go b/packages/iac/area.go
deleted file mode 100644
index 7140e553e0b9d94986f4bdbeeee5fcca0bd8e2b6..0000000000000000000000000000000000000000
--- a/packages/iac/area.go
+++ /dev/null
@@ -1,38 +0,0 @@
-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
-)
diff --git a/packages/iac/errors.go b/packages/iac/errors.go
deleted file mode 100644
index 021c0a0bf7ef56c079e11105e9f0567f892b9079..0000000000000000000000000000000000000000
--- a/packages/iac/errors.go
+++ /dev/null
@@ -1,8 +0,0 @@
-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")
-)
diff --git a/packages/iac/iac.go b/packages/iac/iac.go
deleted file mode 100644
index e1e69661f2fca07bd24132befde5087e0182d22e..0000000000000000000000000000000000000000
--- a/packages/iac/iac.go
+++ /dev/null
@@ -1,25 +0,0 @@
-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
-}
diff --git a/packages/iac/olc_conversion.go b/packages/iac/olc_conversion.go
deleted file mode 100644
index 632280d778645545b191faf61a3bab00c88855b8..0000000000000000000000000000000000000000
--- a/packages/iac/olc_conversion.go
+++ /dev/null
@@ -1,56 +0,0 @@
-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
-}
diff --git a/packages/identity/constants.go b/packages/identity/constants.go
deleted file mode 100644
index 0e23d6ede985f84190bf29282726a50d10eeef53..0000000000000000000000000000000000000000
--- a/packages/identity/constants.go
+++ /dev/null
@@ -1,20 +0,0 @@
-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
-)
diff --git a/packages/identity/errors.go b/packages/identity/errors.go
deleted file mode 100644
index 60f5d59b12356acd5153808fe10f9546e7116e1e..0000000000000000000000000000000000000000
--- a/packages/identity/errors.go
+++ /dev/null
@@ -1,8 +0,0 @@
-package identity
-
-import "errors"
-
-var (
- ErrInvalidDataLen = errors.New("identity: invalid input data length")
- ErrInvalidSignature = errors.New("identity: invalid signature")
-)
diff --git a/packages/identity/identity.go b/packages/identity/identity.go
deleted file mode 100644
index e561c81d427da84467a45fc8bbf4b2e6c3342b83..0000000000000000000000000000000000000000
--- a/packages/identity/identity.go
+++ /dev/null
@@ -1,120 +0,0 @@
-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
-}
diff --git a/packages/identity/types.go b/packages/identity/types.go
deleted file mode 100644
index 30565ab6786fc441931203041602e4d47b1e539f..0000000000000000000000000000000000000000
--- a/packages/identity/types.go
+++ /dev/null
@@ -1,3 +0,0 @@
-package identity
-
-type IdentityType int
diff --git a/packages/network/udp/events.go b/packages/network/udp/events.go
deleted file mode 100644
index 590c6c256b07500a11f109e7d406717de6cca1a9..0000000000000000000000000000000000000000
--- a/packages/network/udp/events.go
+++ /dev/null
@@ -1,18 +0,0 @@
-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))
-}
diff --git a/packages/network/udp/server.go b/packages/network/udp/server.go
deleted file mode 100644
index 00fe86864cc01c3f31cdf7cb14d9e64444213714..0000000000000000000000000000000000000000
--- a/packages/network/udp/server.go
+++ /dev/null
@@ -1,71 +0,0 @@
-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),
- },
- }
-}
diff --git a/packages/network/udp/types.go b/packages/network/udp/types.go
deleted file mode 100644
index 5ee6236e770225de18527d7209f6aa2e8e67ae70..0000000000000000000000000000000000000000
--- a/packages/network/udp/types.go
+++ /dev/null
@@ -1,9 +0,0 @@
-package udp
-
-import "net"
-
-type Callback = func()
-
-type AddressDataConsumer = func(addr *net.UDPAddr, data []byte)
-
-type ErrorConsumer = func(err error)