diff --git a/.golangci.yml b/.golangci.yml
new file mode 100644
index 0000000000000000000000000000000000000000..6de39205141d50effd3541fe2918da2a22238ad8
--- /dev/null
+++ b/.golangci.yml
@@ -0,0 +1,25 @@
+run:
+    tests: true
+
+linters-settings:
+    gofmt:
+        simplify: true
+    golint:
+        min-confidence: 0.9
+    gocyclo:
+        min-complexity: 15
+    govet:
+        check-shadowing: true
+    misspell:
+        locale: US
+
+linters:
+    enable:
+        - misspell
+        - gofmt
+        - goimports
+        - govet
+    disable:
+        - errcheck
+        - gochecknoglobals
+        - golint
diff --git a/packages/database/database.go b/packages/database/database.go
index d1fe569f7ed5a6012b9a396cd3ac8c76fdb069a7..0689992511df0c9b06c20dd81d2afd453639c436 100644
--- a/packages/database/database.go
+++ b/packages/database/database.go
@@ -80,14 +80,16 @@ func (this *databaseImpl) Set(key []byte, value []byte) error {
 }
 
 func (this *databaseImpl) Contains(key []byte) (bool, error) {
-	if err := this.db.View(func(txn *badger.Txn) error {
+	err := this.db.View(func(txn *badger.Txn) error {
 		_, err := txn.Get(key)
 		if err != nil {
 			return err
 		}
 
 		return nil
-	}); err == ErrKeyNotFound {
+	})
+
+	if err == ErrKeyNotFound {
 		return false, nil
 	} else {
 		return err == nil, err
@@ -96,9 +98,8 @@ func (this *databaseImpl) Contains(key []byte) (bool, error) {
 
 func (this *databaseImpl) Get(key []byte) ([]byte, error) {
 	var result []byte = nil
-	var err error = nil
 
-	err = this.db.View(func(txn *badger.Txn) error {
+	err := this.db.View(func(txn *badger.Txn) error {
 		item, err := txn.Get(key)
 		if err != nil {
 			return err
@@ -114,6 +115,40 @@ func (this *databaseImpl) Get(key []byte) ([]byte, error) {
 	return result, err
 }
 
+func (this *databaseImpl) Delete(key []byte) error {
+	err := this.db.Update(func(txn *badger.Txn) error {
+		err := txn.Delete(key)
+		return err
+	})
+	return err
+}
+
+func (this *databaseImpl) ForEach(consumer func([]byte, []byte)) error {
+	err := this.db.View(func(txn *badger.Txn) error {
+		// create an iterator the default options
+		it := txn.NewIterator(badger.DefaultIteratorOptions)
+		defer it.Close()
+
+		// avoid allocations by reusing the value buffer
+		var value []byte
+
+		// loop through every key-value-pair and call the function
+		for it.Rewind(); it.Valid(); it.Next() {
+			item := it.Item()
+
+			var err error
+			value, err = item.ValueCopy(value)
+			if err != nil {
+				return err
+			}
+
+			consumer(item.Key(), value)
+		}
+		return nil
+	})
+	return err
+}
+
 func (this *databaseImpl) Close() error {
 	this.openLock.Lock()
 	defer this.openLock.Unlock()
diff --git a/packages/database/interfaces.go b/packages/database/interfaces.go
index 26b3a5863a360404ac48baff94f41ed3423bc2a4..064e311bc9f9b263538afb036bc30368ccd7f15e 100644
--- a/packages/database/interfaces.go
+++ b/packages/database/interfaces.go
@@ -3,7 +3,9 @@ package database
 type Database interface {
 	Open() error
 	Set(key []byte, value []byte) error
-	Get(key []byte) ([]byte, error)
 	Contains(key []byte) (bool, error)
+	Get(key []byte) ([]byte, error)
+	ForEach(func(key []byte, value []byte)) error
+	Delete(key []byte) error
 	Close() error
 }
diff --git a/packages/datastructure/doubly_linked_list_test.go b/packages/datastructure/doubly_linked_list_test.go
index 4e44086a10857a1bf208fdbebc77e9c62c41afd8..7d43f0ce38cab6274d1b66352a6f6d5afe1799d1 100644
--- a/packages/datastructure/doubly_linked_list_test.go
+++ b/packages/datastructure/doubly_linked_list_test.go
@@ -29,11 +29,9 @@ func TestDelete(t *testing.T) {
 		t.Error(err)
 	}
 
-	firstEntry, err := doublyLinkedList.GetFirst()
-	if err != nil {
+	if firstEntry, err := doublyLinkedList.GetFirst(); err != nil {
 		t.Error(err)
-	}
-	if firstEntry != 13 {
+	} else if firstEntry != 13 {
 		t.Error("first entry should be 13 after delete")
 	}
 
@@ -41,11 +39,9 @@ func TestDelete(t *testing.T) {
 		t.Error(err)
 	}
 
-	lastEntry, err := doublyLinkedList.GetLast()
-	if err != nil {
+	if lastEntry, err := doublyLinkedList.GetLast(); err != nil {
 		t.Error(err)
-	}
-	if lastEntry != 15 {
+	} else if lastEntry != 15 {
 		t.Error("last entry should be 15 after delete")
 	}
 
diff --git a/packages/datastructure/lru_cache_test.go b/packages/datastructure/lru_cache_test.go
index ac5dbd74c0efa830f940a9f79931e3147fad2e8d..5d314374e9133c30b97e34fcb251ff945f57719d 100644
--- a/packages/datastructure/lru_cache_test.go
+++ b/packages/datastructure/lru_cache_test.go
@@ -56,9 +56,16 @@ func TestLRUCache(t *testing.T) {
 		t.Error("'b' should have been dropped")
 	}
 
-	cache.ComputeIfAbsent("tust", func() interface{} {
-		return 1337
-	})
+	{
+		key, value := "test2", 1337
+
+		cache.ComputeIfAbsent(key, func() interface{} {
+			return value
+		})
+		if cache.Get(key) != value {
+			t.Error("'" + key + "' should have been added")
+		}
+	}
 
 	if cache.GetSize() != 5 {
 		t.Error("the size should be 5")
diff --git a/packages/iac/iac.go b/packages/iac/iac.go
index 4d8153c49dfa10bd2db75e3569683dccb581e49f..02e860dbed7d4b6962d359d5d1e3347c55ccd221 100644
--- a/packages/iac/iac.go
+++ b/packages/iac/iac.go
@@ -7,7 +7,7 @@ import (
 )
 
 func Decode(trinary ternary.Trinary) (result *Area, err errors.IdentifiableError) {
-	if olcCode, conversionErr := OLCCodeFromTrinary(trinary); err != nil {
+	if olcCode, conversionErr := OLCCodeFromTrinary(trinary); conversionErr != nil {
 		err = conversionErr
 	} else {
 		if codeArea, olcErr := olc.Decode(olcCode); olcErr == nil {
diff --git a/packages/typeutils/typeutils.go b/packages/typeutils/typeutils.go
index e59ebe2e778da37709e8485315763672618d22d9..eed90cf95478febc1fd3248a2d3ce5c90b7007bf 100644
--- a/packages/typeutils/typeutils.go
+++ b/packages/typeutils/typeutils.go
@@ -8,7 +8,7 @@ import (
 func BytesToString(b []byte) string {
 	bh := (*reflect.SliceHeader)(unsafe.Pointer(&b))
 
-	return *(*string)(unsafe.Pointer(&reflect.StringHeader{bh.Data, bh.Len}))
+	return *(*string)(unsafe.Pointer(&reflect.StringHeader{Data: bh.Data, Len: bh.Len}))
 }
 
 func StringToBytes(str string) []byte {
diff --git a/plugins/analysis/server/constants.go b/plugins/analysis/server/constants.go
index 63083804f01cf4f4b15aa1811b8e59f115c8fb55..b4c1f739dd4a89df83743403082fcf930e553634 100644
--- a/plugins/analysis/server/constants.go
+++ b/plugins/analysis/server/constants.go
@@ -16,9 +16,9 @@ const (
 	STATE_INITIAL          = byte(255)
 	STATE_INITIAL_ADDNODE  = byte(254)
 	STATE_CONSECUTIVE      = byte(253)
-	STATE_PING             = ping.MARSHALLED_PACKET_HEADER
-	STATE_ADD_NODE         = addnode.MARSHALLED_PACKET_HEADER
-	STATE_REMOVE_NODE      = removenode.MARSHALLED_PACKET_HEADER
-	STATE_CONNECT_NODES    = connectnodes.MARSHALLED_PACKET_HEADER
-	STATE_DISCONNECT_NODES = disconnectnodes.MARSHALLED_PACKET_HEADER
+	STATE_PING             = ping.MARSHALED_PACKET_HEADER
+	STATE_ADD_NODE         = addnode.MARSHALED_PACKET_HEADER
+	STATE_REMOVE_NODE      = removenode.MARSHALED_PACKET_HEADER
+	STATE_CONNECT_NODES    = connectnodes.MARSHALED_PACKET_HEADER
+	STATE_DISCONNECT_NODES = disconnectnodes.MARSHALED_PACKET_HEADER
 )
diff --git a/plugins/analysis/server/plugin.go b/plugins/analysis/server/plugin.go
index c8e9f0b72859a8d79629787fecf779b442bb2873..86522f1cda3bd0388c24ab1b0a3a065480b8e39f 100644
--- a/plugins/analysis/server/plugin.go
+++ b/plugins/analysis/server/plugin.go
@@ -73,11 +73,11 @@ func HandleConnection(conn *network.ManagedConnection) {
 	conn.Events.Close.Attach(onDisconnect)
 
 	maxPacketsSize := getMaxPacketSize(
-		ping.MARSHALLED_TOTAL_SIZE,
-		addnode.MARSHALLED_TOTAL_SIZE,
-		removenode.MARSHALLED_TOTAL_SIZE,
-		connectnodes.MARSHALLED_TOTAL_SIZE,
-		disconnectnodes.MARSHALLED_PACKET_HEADER,
+		ping.MARSHALED_TOTAL_SIZE,
+		addnode.MARSHALED_TOTAL_SIZE,
+		removenode.MARSHALED_TOTAL_SIZE,
+		connectnodes.MARSHALED_TOTAL_SIZE,
+		disconnectnodes.MARSHALED_PACKET_HEADER,
 	)
 
 	go conn.Read(make([]byte, maxPacketsSize))
@@ -112,19 +112,19 @@ func processIncomingPacket(connectionState *byte, receiveBuffer *[]byte, conn *n
 
 		switch *connectionState {
 		case STATE_ADD_NODE:
-			*receiveBuffer = make([]byte, addnode.MARSHALLED_TOTAL_SIZE)
+			*receiveBuffer = make([]byte, addnode.MARSHALED_TOTAL_SIZE)
 
 		case STATE_PING:
-			*receiveBuffer = make([]byte, ping.MARSHALLED_TOTAL_SIZE)
+			*receiveBuffer = make([]byte, ping.MARSHALED_TOTAL_SIZE)
 
 		case STATE_CONNECT_NODES:
-			*receiveBuffer = make([]byte, connectnodes.MARSHALLED_TOTAL_SIZE)
+			*receiveBuffer = make([]byte, connectnodes.MARSHALED_TOTAL_SIZE)
 
 		case STATE_DISCONNECT_NODES:
-			*receiveBuffer = make([]byte, disconnectnodes.MARSHALLED_TOTAL_SIZE)
+			*receiveBuffer = make([]byte, disconnectnodes.MARSHALED_TOTAL_SIZE)
 
 		case STATE_REMOVE_NODE:
-			*receiveBuffer = make([]byte, removenode.MARSHALLED_TOTAL_SIZE)
+			*receiveBuffer = make([]byte, removenode.MARSHALED_TOTAL_SIZE)
 		}
 	}
 
@@ -162,28 +162,28 @@ func parsePackageHeader(data []byte) (ConnectionState, []byte, error) {
 	var receiveBuffer []byte
 
 	switch data[0] {
-	case ping.MARSHALLED_PACKET_HEADER:
-		receiveBuffer = make([]byte, ping.MARSHALLED_TOTAL_SIZE)
+	case ping.MARSHALED_PACKET_HEADER:
+		receiveBuffer = make([]byte, ping.MARSHALED_TOTAL_SIZE)
 
 		connectionState = STATE_PING
 
-	case addnode.MARSHALLED_PACKET_HEADER:
-		receiveBuffer = make([]byte, addnode.MARSHALLED_TOTAL_SIZE)
+	case addnode.MARSHALED_PACKET_HEADER:
+		receiveBuffer = make([]byte, addnode.MARSHALED_TOTAL_SIZE)
 
 		connectionState = STATE_ADD_NODE
 
-	case connectnodes.MARSHALLED_PACKET_HEADER:
-		receiveBuffer = make([]byte, connectnodes.MARSHALLED_TOTAL_SIZE)
+	case connectnodes.MARSHALED_PACKET_HEADER:
+		receiveBuffer = make([]byte, connectnodes.MARSHALED_TOTAL_SIZE)
 
 		connectionState = STATE_CONNECT_NODES
 
-	case disconnectnodes.MARSHALLED_PACKET_HEADER:
-		receiveBuffer = make([]byte, disconnectnodes.MARSHALLED_TOTAL_SIZE)
+	case disconnectnodes.MARSHALED_PACKET_HEADER:
+		receiveBuffer = make([]byte, disconnectnodes.MARSHALED_TOTAL_SIZE)
 
 		connectionState = STATE_DISCONNECT_NODES
 
-	case removenode.MARSHALLED_PACKET_HEADER:
-		receiveBuffer = make([]byte, removenode.MARSHALLED_TOTAL_SIZE)
+	case removenode.MARSHALED_PACKET_HEADER:
+		receiveBuffer = make([]byte, removenode.MARSHALED_TOTAL_SIZE)
 
 		connectionState = STATE_REMOVE_NODE
 
@@ -195,11 +195,11 @@ func parsePackageHeader(data []byte) (ConnectionState, []byte, error) {
 }
 
 func processIncomingAddNodePacket(connectionState *byte, receiveBuffer *[]byte, conn *network.ManagedConnection, data []byte, offset *int, connectedNodeId *string) {
-	remainingCapacity := int(math.Min(float64(addnode.MARSHALLED_TOTAL_SIZE-*offset), float64(len(data))))
+	remainingCapacity := int(math.Min(float64(addnode.MARSHALED_TOTAL_SIZE-*offset), float64(len(data))))
 
 	copy((*receiveBuffer)[*offset:], data[:remainingCapacity])
 
-	if *offset+len(data) < addnode.MARSHALLED_TOTAL_SIZE {
+	if *offset+len(data) < addnode.MARSHALED_TOTAL_SIZE {
 		*offset += len(data)
 	} else {
 		if addNodePacket, err := addnode.Unmarshal(*receiveBuffer); err != nil {
@@ -222,18 +222,18 @@ func processIncomingAddNodePacket(connectionState *byte, receiveBuffer *[]byte,
 
 		*connectionState = STATE_CONSECUTIVE
 
-		if *offset+len(data) > addnode.MARSHALLED_TOTAL_SIZE {
+		if *offset+len(data) > addnode.MARSHALED_TOTAL_SIZE {
 			processIncomingPacket(connectionState, receiveBuffer, conn, data[remainingCapacity:], offset, connectedNodeId)
 		}
 	}
 }
 
 func processIncomingPingPacket(connectionState *byte, receiveBuffer *[]byte, conn *network.ManagedConnection, data []byte, offset *int, connectedNodeId *string) {
-	remainingCapacity := int(math.Min(float64(ping.MARSHALLED_TOTAL_SIZE-*offset), float64(len(data))))
+	remainingCapacity := int(math.Min(float64(ping.MARSHALED_TOTAL_SIZE-*offset), float64(len(data))))
 
 	copy((*receiveBuffer)[*offset:], data[:remainingCapacity])
 
-	if *offset+len(data) < ping.MARSHALLED_TOTAL_SIZE {
+	if *offset+len(data) < ping.MARSHALED_TOTAL_SIZE {
 		*offset += len(data)
 	} else {
 		if _, err := ping.Unmarshal(*receiveBuffer); err != nil {
@@ -246,18 +246,18 @@ func processIncomingPingPacket(connectionState *byte, receiveBuffer *[]byte, con
 
 		*connectionState = STATE_CONSECUTIVE
 
-		if *offset+len(data) > ping.MARSHALLED_TOTAL_SIZE {
+		if *offset+len(data) > ping.MARSHALED_TOTAL_SIZE {
 			processIncomingPacket(connectionState, receiveBuffer, conn, data[remainingCapacity:], offset, connectedNodeId)
 		}
 	}
 }
 
 func processIncomingConnectNodesPacket(connectionState *byte, receiveBuffer *[]byte, conn *network.ManagedConnection, data []byte, offset *int, connectedNodeId *string) {
-	remainingCapacity := int(math.Min(float64(connectnodes.MARSHALLED_TOTAL_SIZE-*offset), float64(len(data))))
+	remainingCapacity := int(math.Min(float64(connectnodes.MARSHALED_TOTAL_SIZE-*offset), float64(len(data))))
 
 	copy((*receiveBuffer)[*offset:], data[:remainingCapacity])
 
-	if *offset+len(data) < connectnodes.MARSHALLED_TOTAL_SIZE {
+	if *offset+len(data) < connectnodes.MARSHALED_TOTAL_SIZE {
 		*offset += len(data)
 	} else {
 		if connectNodesPacket, err := connectnodes.Unmarshal(*receiveBuffer); err != nil {
@@ -275,18 +275,18 @@ func processIncomingConnectNodesPacket(connectionState *byte, receiveBuffer *[]b
 
 		*connectionState = STATE_CONSECUTIVE
 
-		if *offset+len(data) > connectnodes.MARSHALLED_TOTAL_SIZE {
+		if *offset+len(data) > connectnodes.MARSHALED_TOTAL_SIZE {
 			processIncomingPacket(connectionState, receiveBuffer, conn, data[remainingCapacity:], offset, connectedNodeId)
 		}
 	}
 }
 
 func processIncomingDisconnectNodesPacket(connectionState *byte, receiveBuffer *[]byte, conn *network.ManagedConnection, data []byte, offset *int, connectedNodeId *string) {
-	remainingCapacity := int(math.Min(float64(disconnectnodes.MARSHALLED_TOTAL_SIZE-*offset), float64(len(data))))
+	remainingCapacity := int(math.Min(float64(disconnectnodes.MARSHALED_TOTAL_SIZE-*offset), float64(len(data))))
 
 	copy((*receiveBuffer)[*offset:], data[:remainingCapacity])
 
-	if *offset+len(data) < disconnectnodes.MARSHALLED_TOTAL_SIZE {
+	if *offset+len(data) < disconnectnodes.MARSHALED_TOTAL_SIZE {
 		*offset += len(data)
 	} else {
 		if disconnectNodesPacket, err := disconnectnodes.Unmarshal(*receiveBuffer); err != nil {
@@ -304,7 +304,7 @@ func processIncomingDisconnectNodesPacket(connectionState *byte, receiveBuffer *
 
 		*connectionState = STATE_CONSECUTIVE
 
-		if *offset+len(data) > disconnectnodes.MARSHALLED_TOTAL_SIZE {
+		if *offset+len(data) > disconnectnodes.MARSHALED_TOTAL_SIZE {
 			processIncomingPacket(connectionState, receiveBuffer, conn, data[remainingCapacity:], offset, connectedNodeId)
 		}
 	}
diff --git a/plugins/analysis/types/addnode/constants.go b/plugins/analysis/types/addnode/constants.go
index 43636315d3945f1a95b981617c6a02397e1afc7e..6534ce8da6a998cb4356343f4a886c00d145b0d3 100644
--- a/plugins/analysis/types/addnode/constants.go
+++ b/plugins/analysis/types/addnode/constants.go
@@ -1,15 +1,15 @@
 package addnode
 
 const (
-	MARSHALLED_PACKET_HEADER = 0x01
+	MARSHALED_PACKET_HEADER = 0x01
 
-	MARSHALLED_PACKET_HEADER_START = 0
-	MARSHALLED_PACKET_HEADER_SIZE  = 1
-	MARSHALLED_PACKET_HEADER_END   = MARSHALLED_PACKET_HEADER_START + MARSHALLED_PACKET_HEADER_SIZE
+	MARSHALED_PACKET_HEADER_START = 0
+	MARSHALED_PACKET_HEADER_SIZE  = 1
+	MARSHALED_PACKET_HEADER_END   = MARSHALED_PACKET_HEADER_START + MARSHALED_PACKET_HEADER_SIZE
 
-	MARSHALLED_ID_START = MARSHALLED_PACKET_HEADER_END
-	MARSHALLED_ID_SIZE  = 20
-	MARSHALLED_ID_END   = MARSHALLED_ID_START + MARSHALLED_ID_SIZE
+	MARSHALED_ID_START = MARSHALED_PACKET_HEADER_END
+	MARSHALED_ID_SIZE  = 20
+	MARSHALED_ID_END   = MARSHALED_ID_START + MARSHALED_ID_SIZE
 
-	MARSHALLED_TOTAL_SIZE = MARSHALLED_ID_END
+	MARSHALED_TOTAL_SIZE = MARSHALED_ID_END
 )
diff --git a/plugins/analysis/types/addnode/packet.go b/plugins/analysis/types/addnode/packet.go
index d378b677f1ee33b96fd0dde80724901d476350bd..79d0274db22a87a6125fb00ea009d4fbf019a916 100644
--- a/plugins/analysis/types/addnode/packet.go
+++ b/plugins/analysis/types/addnode/packet.go
@@ -7,24 +7,24 @@ type Packet struct {
 }
 
 func Unmarshal(data []byte) (*Packet, error) {
-	if len(data) < MARSHALLED_TOTAL_SIZE || data[0] != MARSHALLED_PACKET_HEADER {
+	if len(data) < MARSHALED_TOTAL_SIZE || data[0] != MARSHALED_PACKET_HEADER {
 		return nil, errors.New("malformed add node packet")
 	}
 
-	unmarshalledPackage := &Packet{
-		NodeId: make([]byte, MARSHALLED_ID_SIZE),
+	unmarshaledPackage := &Packet{
+		NodeId: make([]byte, MARSHALED_ID_SIZE),
 	}
 
-	copy(unmarshalledPackage.NodeId, data[MARSHALLED_ID_START:MARSHALLED_ID_END])
+	copy(unmarshaledPackage.NodeId, data[MARSHALED_ID_START:MARSHALED_ID_END])
 
-	return unmarshalledPackage, nil
+	return unmarshaledPackage, nil
 }
 
 func (packet *Packet) Marshal() []byte {
-	marshalledPackage := make([]byte, MARSHALLED_TOTAL_SIZE)
+	marshaledPackage := make([]byte, MARSHALED_TOTAL_SIZE)
 
-	marshalledPackage[MARSHALLED_PACKET_HEADER_START] = MARSHALLED_PACKET_HEADER
-	copy(marshalledPackage[MARSHALLED_ID_START:MARSHALLED_ID_END], packet.NodeId[:MARSHALLED_ID_SIZE])
+	marshaledPackage[MARSHALED_PACKET_HEADER_START] = MARSHALED_PACKET_HEADER
+	copy(marshaledPackage[MARSHALED_ID_START:MARSHALED_ID_END], packet.NodeId[:MARSHALED_ID_SIZE])
 
-	return marshalledPackage
+	return marshaledPackage
 }
diff --git a/plugins/analysis/types/connectnodes/constants.go b/plugins/analysis/types/connectnodes/constants.go
index 564264dfc3f9b23dc71237d6f87d469c4011deeb..d40065208b1a3f07ab3c57758932598aa8c3c2c1 100644
--- a/plugins/analysis/types/connectnodes/constants.go
+++ b/plugins/analysis/types/connectnodes/constants.go
@@ -1,19 +1,19 @@
 package connectnodes
 
 const (
-	MARSHALLED_PACKET_HEADER = 0x03
+	MARSHALED_PACKET_HEADER = 0x03
 
-	MARSHALLED_PACKET_HEADER_START = 0
-	MARSHALLED_PACKET_HEADER_SIZE  = 1
-	MARSHALLED_PACKET_HEADER_END   = MARSHALLED_PACKET_HEADER_START + MARSHALLED_PACKET_HEADER_SIZE
+	MARSHALED_PACKET_HEADER_START = 0
+	MARSHALED_PACKET_HEADER_SIZE  = 1
+	MARSHALED_PACKET_HEADER_END   = MARSHALED_PACKET_HEADER_START + MARSHALED_PACKET_HEADER_SIZE
 
-	MARSHALLED_SOURCE_ID_START = MARSHALLED_PACKET_HEADER_END
-	MARSHALLED_SOURCE_ID_SIZE  = 20
-	MARSHALLED_SOURCE_ID_END   = MARSHALLED_SOURCE_ID_START + MARSHALLED_SOURCE_ID_SIZE
+	MARSHALED_SOURCE_ID_START = MARSHALED_PACKET_HEADER_END
+	MARSHALED_SOURCE_ID_SIZE  = 20
+	MARSHALED_SOURCE_ID_END   = MARSHALED_SOURCE_ID_START + MARSHALED_SOURCE_ID_SIZE
 
-	MARSHALLED_TARGET_ID_START = MARSHALLED_SOURCE_ID_END
-	MARSHALLED_TARGET_ID_SIZE  = 20
-	MARSHALLED_TARGET_ID_END   = MARSHALLED_TARGET_ID_START + MARSHALLED_TARGET_ID_SIZE
+	MARSHALED_TARGET_ID_START = MARSHALED_SOURCE_ID_END
+	MARSHALED_TARGET_ID_SIZE  = 20
+	MARSHALED_TARGET_ID_END   = MARSHALED_TARGET_ID_START + MARSHALED_TARGET_ID_SIZE
 
-	MARSHALLED_TOTAL_SIZE = MARSHALLED_TARGET_ID_END
+	MARSHALED_TOTAL_SIZE = MARSHALED_TARGET_ID_END
 )
diff --git a/plugins/analysis/types/connectnodes/packet.go b/plugins/analysis/types/connectnodes/packet.go
index 954c560744f58d9931d3948bcc0ef777baa397dd..7d9c05a8150da41bec26c53485ed6c442e6cf32b 100644
--- a/plugins/analysis/types/connectnodes/packet.go
+++ b/plugins/analysis/types/connectnodes/packet.go
@@ -8,27 +8,27 @@ type Packet struct {
 }
 
 func Unmarshal(data []byte) (*Packet, error) {
-	if len(data) < MARSHALLED_TOTAL_SIZE || data[0] != MARSHALLED_PACKET_HEADER {
+	if len(data) < MARSHALED_TOTAL_SIZE || data[0] != MARSHALED_PACKET_HEADER {
 		return nil, errors.New("malformed connect nodes packet")
 	}
 
-	unmarshalledPackage := &Packet{
-		SourceId: make([]byte, MARSHALLED_SOURCE_ID_SIZE),
-		TargetId: make([]byte, MARSHALLED_TARGET_ID_SIZE),
+	unmarshaledPackage := &Packet{
+		SourceId: make([]byte, MARSHALED_SOURCE_ID_SIZE),
+		TargetId: make([]byte, MARSHALED_TARGET_ID_SIZE),
 	}
 
-	copy(unmarshalledPackage.SourceId, data[MARSHALLED_SOURCE_ID_START:MARSHALLED_SOURCE_ID_END])
-	copy(unmarshalledPackage.TargetId, data[MARSHALLED_TARGET_ID_START:MARSHALLED_TARGET_ID_END])
+	copy(unmarshaledPackage.SourceId, data[MARSHALED_SOURCE_ID_START:MARSHALED_SOURCE_ID_END])
+	copy(unmarshaledPackage.TargetId, data[MARSHALED_TARGET_ID_START:MARSHALED_TARGET_ID_END])
 
-	return unmarshalledPackage, nil
+	return unmarshaledPackage, nil
 }
 
 func (packet *Packet) Marshal() []byte {
-	marshalledPackage := make([]byte, MARSHALLED_TOTAL_SIZE)
+	marshaledPackage := make([]byte, MARSHALED_TOTAL_SIZE)
 
-	marshalledPackage[MARSHALLED_PACKET_HEADER_START] = MARSHALLED_PACKET_HEADER
-	copy(marshalledPackage[MARSHALLED_SOURCE_ID_START:MARSHALLED_SOURCE_ID_END], packet.SourceId[:MARSHALLED_SOURCE_ID_SIZE])
-	copy(marshalledPackage[MARSHALLED_TARGET_ID_START:MARSHALLED_TARGET_ID_END], packet.TargetId[:MARSHALLED_TARGET_ID_SIZE])
+	marshaledPackage[MARSHALED_PACKET_HEADER_START] = MARSHALED_PACKET_HEADER
+	copy(marshaledPackage[MARSHALED_SOURCE_ID_START:MARSHALED_SOURCE_ID_END], packet.SourceId[:MARSHALED_SOURCE_ID_SIZE])
+	copy(marshaledPackage[MARSHALED_TARGET_ID_START:MARSHALED_TARGET_ID_END], packet.TargetId[:MARSHALED_TARGET_ID_SIZE])
 
-	return marshalledPackage
+	return marshaledPackage
 }
diff --git a/plugins/analysis/types/disconnectnodes/constants.go b/plugins/analysis/types/disconnectnodes/constants.go
index 5145c9090ddc53e41e60e9dd57cfd1048bd91b85..928a723f9e3639c351116e4b6e8746e70ceca4b2 100644
--- a/plugins/analysis/types/disconnectnodes/constants.go
+++ b/plugins/analysis/types/disconnectnodes/constants.go
@@ -1,19 +1,19 @@
 package disconnectnodes
 
 const (
-	MARSHALLED_PACKET_HEADER = 0x04
+	MARSHALED_PACKET_HEADER = 0x04
 
-	MARSHALLED_PACKET_HEADER_START = 0
-	MARSHALLED_PACKET_HEADER_SIZE  = 1
-	MARSHALLED_PACKET_HEADER_END   = MARSHALLED_PACKET_HEADER_START + MARSHALLED_PACKET_HEADER_SIZE
+	MARSHALED_PACKET_HEADER_START = 0
+	MARSHALED_PACKET_HEADER_SIZE  = 1
+	MARSHALED_PACKET_HEADER_END   = MARSHALED_PACKET_HEADER_START + MARSHALED_PACKET_HEADER_SIZE
 
-	MARSHALLED_SOURCE_ID_START = MARSHALLED_PACKET_HEADER_END
-	MARSHALLED_SOURCE_ID_SIZE  = 20
-	MARSHALLED_SOURCE_ID_END   = MARSHALLED_SOURCE_ID_START + MARSHALLED_SOURCE_ID_SIZE
+	MARSHALED_SOURCE_ID_START = MARSHALED_PACKET_HEADER_END
+	MARSHALED_SOURCE_ID_SIZE  = 20
+	MARSHALED_SOURCE_ID_END   = MARSHALED_SOURCE_ID_START + MARSHALED_SOURCE_ID_SIZE
 
-	MARSHALLED_TARGET_ID_START = MARSHALLED_SOURCE_ID_END
-	MARSHALLED_TARGET_ID_SIZE  = 20
-	MARSHALLED_TARGET_ID_END   = MARSHALLED_TARGET_ID_START + MARSHALLED_TARGET_ID_SIZE
+	MARSHALED_TARGET_ID_START = MARSHALED_SOURCE_ID_END
+	MARSHALED_TARGET_ID_SIZE  = 20
+	MARSHALED_TARGET_ID_END   = MARSHALED_TARGET_ID_START + MARSHALED_TARGET_ID_SIZE
 
-	MARSHALLED_TOTAL_SIZE = MARSHALLED_TARGET_ID_END
+	MARSHALED_TOTAL_SIZE = MARSHALED_TARGET_ID_END
 )
diff --git a/plugins/analysis/types/disconnectnodes/packet.go b/plugins/analysis/types/disconnectnodes/packet.go
index bf7086452f6229ddcb129e643df8c9278e1b7572..9193312e412eff118f3b209ba912ee2f10bf2bcf 100644
--- a/plugins/analysis/types/disconnectnodes/packet.go
+++ b/plugins/analysis/types/disconnectnodes/packet.go
@@ -8,27 +8,27 @@ type Packet struct {
 }
 
 func Unmarshal(data []byte) (*Packet, error) {
-	if len(data) < MARSHALLED_TOTAL_SIZE || data[0] != MARSHALLED_PACKET_HEADER {
+	if len(data) < MARSHALED_TOTAL_SIZE || data[0] != MARSHALED_PACKET_HEADER {
 		return nil, errors.New("malformed disconnect nodes packet")
 	}
 
-	unmarshalledPackage := &Packet{
-		SourceId: make([]byte, MARSHALLED_SOURCE_ID_SIZE),
-		TargetId: make([]byte, MARSHALLED_TARGET_ID_SIZE),
+	unmarshaledPackage := &Packet{
+		SourceId: make([]byte, MARSHALED_SOURCE_ID_SIZE),
+		TargetId: make([]byte, MARSHALED_TARGET_ID_SIZE),
 	}
 
-	copy(unmarshalledPackage.SourceId, data[MARSHALLED_SOURCE_ID_START:MARSHALLED_SOURCE_ID_END])
-	copy(unmarshalledPackage.TargetId, data[MARSHALLED_TARGET_ID_START:MARSHALLED_TARGET_ID_END])
+	copy(unmarshaledPackage.SourceId, data[MARSHALED_SOURCE_ID_START:MARSHALED_SOURCE_ID_END])
+	copy(unmarshaledPackage.TargetId, data[MARSHALED_TARGET_ID_START:MARSHALED_TARGET_ID_END])
 
-	return unmarshalledPackage, nil
+	return unmarshaledPackage, nil
 }
 
 func (packet *Packet) Marshal() []byte {
-	marshalledPackage := make([]byte, MARSHALLED_TOTAL_SIZE)
+	marshaledPackage := make([]byte, MARSHALED_TOTAL_SIZE)
 
-	marshalledPackage[MARSHALLED_PACKET_HEADER_START] = MARSHALLED_PACKET_HEADER
-	copy(marshalledPackage[MARSHALLED_SOURCE_ID_START:MARSHALLED_SOURCE_ID_END], packet.SourceId[:MARSHALLED_SOURCE_ID_SIZE])
-	copy(marshalledPackage[MARSHALLED_TARGET_ID_START:MARSHALLED_TARGET_ID_END], packet.TargetId[:MARSHALLED_TARGET_ID_SIZE])
+	marshaledPackage[MARSHALED_PACKET_HEADER_START] = MARSHALED_PACKET_HEADER
+	copy(marshaledPackage[MARSHALED_SOURCE_ID_START:MARSHALED_SOURCE_ID_END], packet.SourceId[:MARSHALED_SOURCE_ID_SIZE])
+	copy(marshaledPackage[MARSHALED_TARGET_ID_START:MARSHALED_TARGET_ID_END], packet.TargetId[:MARSHALED_TARGET_ID_SIZE])
 
-	return marshalledPackage
+	return marshaledPackage
 }
diff --git a/plugins/analysis/types/ping/constants.go b/plugins/analysis/types/ping/constants.go
index f3fd24bfe29b3abde21bdc786a77600c452e5916..41de5de4342d2f55f4fa5e9b053bdead43d37fd8 100644
--- a/plugins/analysis/types/ping/constants.go
+++ b/plugins/analysis/types/ping/constants.go
@@ -1,11 +1,11 @@
 package ping
 
 const (
-	MARSHALLED_PACKET_HEADER = 0x00
+	MARSHALED_PACKET_HEADER = 0x00
 
-	MARSHALLED_PACKET_HEADER_START = 0
-	MARSHALLED_PACKET_HEADER_SIZE  = 1
-	MARSHALLED_PACKET_HEADER_END   = MARSHALLED_PACKET_HEADER_START + MARSHALLED_PACKET_HEADER_SIZE
+	MARSHALED_PACKET_HEADER_START = 0
+	MARSHALED_PACKET_HEADER_SIZE  = 1
+	MARSHALED_PACKET_HEADER_END   = MARSHALED_PACKET_HEADER_START + MARSHALED_PACKET_HEADER_SIZE
 
-	MARSHALLED_TOTAL_SIZE = MARSHALLED_PACKET_HEADER_END
+	MARSHALED_TOTAL_SIZE = MARSHALED_PACKET_HEADER_END
 )
diff --git a/plugins/analysis/types/ping/packet.go b/plugins/analysis/types/ping/packet.go
index 89728d17e8c1eb0adb7aafdf41c9405dfd880475..6325771df3a49621fb44a14141b703e94d2e8ad4 100644
--- a/plugins/analysis/types/ping/packet.go
+++ b/plugins/analysis/types/ping/packet.go
@@ -5,19 +5,19 @@ import "github.com/pkg/errors"
 type Packet struct{}
 
 func Unmarshal(data []byte) (*Packet, error) {
-	if len(data) < MARSHALLED_TOTAL_SIZE || data[MARSHALLED_PACKET_HEADER_START] != MARSHALLED_PACKET_HEADER {
+	if len(data) < MARSHALED_TOTAL_SIZE || data[MARSHALED_PACKET_HEADER_START] != MARSHALED_PACKET_HEADER {
 		return nil, errors.New("malformed ping packet")
 	}
 
-	unmarshalledPacket := &Packet{}
+	unmarshaledPacket := &Packet{}
 
-	return unmarshalledPacket, nil
+	return unmarshaledPacket, nil
 }
 
 func (packet *Packet) Marshal() []byte {
-	marshalledPackage := make([]byte, MARSHALLED_TOTAL_SIZE)
+	marshaledPackage := make([]byte, MARSHALED_TOTAL_SIZE)
 
-	marshalledPackage[MARSHALLED_PACKET_HEADER_START] = MARSHALLED_PACKET_HEADER
+	marshaledPackage[MARSHALED_PACKET_HEADER_START] = MARSHALED_PACKET_HEADER
 
-	return marshalledPackage
+	return marshaledPackage
 }
diff --git a/plugins/analysis/types/removenode/constants.go b/plugins/analysis/types/removenode/constants.go
index 269d4becb15ca1f2013f5651a03eda83888ce34f..52d9bcc5c0a02d3a8cd734ff7c4395a5cd7687b2 100644
--- a/plugins/analysis/types/removenode/constants.go
+++ b/plugins/analysis/types/removenode/constants.go
@@ -1,15 +1,15 @@
 package removenode
 
 const (
-	MARSHALLED_PACKET_HEADER = 0x02
+	MARSHALED_PACKET_HEADER = 0x02
 
-	MARSHALLED_PACKET_HEADER_START = 0
-	MARSHALLED_PACKET_HEADER_SIZE  = 1
-	MARSHALLED_PACKET_HEADER_END   = MARSHALLED_PACKET_HEADER_START + MARSHALLED_PACKET_HEADER_SIZE
+	MARSHALED_PACKET_HEADER_START = 0
+	MARSHALED_PACKET_HEADER_SIZE  = 1
+	MARSHALED_PACKET_HEADER_END   = MARSHALED_PACKET_HEADER_START + MARSHALED_PACKET_HEADER_SIZE
 
-	MARSHALLED_ID_START = MARSHALLED_PACKET_HEADER_END
-	MARSHALLED_ID_SIZE  = 20
-	MARSHALLED_ID_END   = MARSHALLED_ID_START + MARSHALLED_ID_SIZE
+	MARSHALED_ID_START = MARSHALED_PACKET_HEADER_END
+	MARSHALED_ID_SIZE  = 20
+	MARSHALED_ID_END   = MARSHALED_ID_START + MARSHALED_ID_SIZE
 
-	MARSHALLED_TOTAL_SIZE = MARSHALLED_ID_END
+	MARSHALED_TOTAL_SIZE = MARSHALED_ID_END
 )
diff --git a/plugins/analysis/types/removenode/packet.go b/plugins/analysis/types/removenode/packet.go
index 504f3f3cb3550de7df8a356c4225d4f555f30ee0..c44bf94b4bed6688f41dadcf6109384993877cc2 100644
--- a/plugins/analysis/types/removenode/packet.go
+++ b/plugins/analysis/types/removenode/packet.go
@@ -7,24 +7,24 @@ type Packet struct {
 }
 
 func Unmarshal(data []byte) (*Packet, error) {
-	if len(data) < MARSHALLED_TOTAL_SIZE || data[0] != MARSHALLED_PACKET_HEADER {
+	if len(data) < MARSHALED_TOTAL_SIZE || data[0] != MARSHALED_PACKET_HEADER {
 		return nil, errors.New("malformed remove node packet")
 	}
 
-	unmarshalledPackage := &Packet{
-		NodeId: make([]byte, MARSHALLED_ID_SIZE),
+	unmarshaledPackage := &Packet{
+		NodeId: make([]byte, MARSHALED_ID_SIZE),
 	}
 
-	copy(unmarshalledPackage.NodeId, data[MARSHALLED_ID_START:MARSHALLED_ID_END])
+	copy(unmarshaledPackage.NodeId, data[MARSHALED_ID_START:MARSHALED_ID_END])
 
-	return unmarshalledPackage, nil
+	return unmarshaledPackage, nil
 }
 
 func (packet *Packet) Marshal() []byte {
-	marshalledPackage := make([]byte, MARSHALLED_TOTAL_SIZE)
+	marshaledPackage := make([]byte, MARSHALED_TOTAL_SIZE)
 
-	marshalledPackage[MARSHALLED_PACKET_HEADER_START] = MARSHALLED_PACKET_HEADER
-	copy(marshalledPackage[MARSHALLED_ID_START:MARSHALLED_ID_END], packet.NodeId[:MARSHALLED_ID_SIZE])
+	marshaledPackage[MARSHALED_PACKET_HEADER_START] = MARSHALED_PACKET_HEADER
+	copy(marshaledPackage[MARSHALED_ID_START:MARSHALED_ID_END], packet.NodeId[:MARSHALED_ID_SIZE])
 
-	return marshalledPackage
+	return marshaledPackage
 }
diff --git a/plugins/analysis/webinterface/recordedevents/recorded_events.go b/plugins/analysis/webinterface/recordedevents/recorded_events.go
index 19aa2035b7b42e95ffe0eb2d9d770a1e46eeb25c..3110aa6a70614faaf0a066e7f2aa0588d51d7b50 100644
--- a/plugins/analysis/webinterface/recordedevents/recorded_events.go
+++ b/plugins/analysis/webinterface/recordedevents/recorded_events.go
@@ -9,8 +9,6 @@ import (
 	"github.com/iotaledger/goshimmer/plugins/analysis/webinterface/types"
 )
 
-var recordedEvents = make([]types.EventHandlersConsumer, 0)
-
 var nodes = make(map[string]bool)
 var links = make(map[string]map[string]bool)
 
@@ -84,7 +82,7 @@ func Replay(handlers *types.EventHandlers) {
 	}
 
 	for sourceId, targetMap := range links {
-		for targetId, _ := range targetMap {
+		for targetId := range targetMap {
 			handlers.ConnectNodes(sourceId, targetId)
 		}
 	}
diff --git a/plugins/autopeering/peerstorage/peerstorage.go b/plugins/autopeering/peerstorage/peerstorage.go
new file mode 100644
index 0000000000000000000000000000000000000000..5ea1c80fc4aa81515d42c8d89f1881e2fcbb6f93
--- /dev/null
+++ b/plugins/autopeering/peerstorage/peerstorage.go
@@ -0,0 +1,82 @@
+package peerstorage
+
+import (
+	"bytes"
+	"strconv"
+
+	"github.com/iotaledger/goshimmer/packages/database"
+	"github.com/iotaledger/goshimmer/packages/events"
+	"github.com/iotaledger/goshimmer/packages/node"
+	"github.com/iotaledger/goshimmer/plugins/autopeering/instances/knownpeers"
+	"github.com/iotaledger/goshimmer/plugins/autopeering/types/peer"
+)
+
+const peerDbName string = "peers"
+
+var peerDb database.Database
+
+func initDb() {
+	db, err := database.Get(peerDbName)
+	if err != nil {
+		panic(err)
+	}
+
+	peerDb = db
+}
+
+func storePeer(p *peer.Peer) {
+	err := peerDb.Set(p.Identity.Identifier, p.Marshal())
+	if err != nil {
+		panic(err)
+	}
+}
+
+func removePeer(p *peer.Peer) {
+	err := peerDb.Delete(p.Identity.Identifier)
+	if err != nil {
+		panic(err)
+	}
+}
+
+func loadPeers(plugin *node.Plugin) {
+	var count int
+
+	err := peerDb.ForEach(func(key []byte, value []byte) {
+		peer, err := peer.Unmarshal(value)
+		if err != nil {
+			panic(err)
+		}
+		// the peers are stored by identifier in the db
+		if !bytes.Equal(key, peer.Identity.Identifier) {
+			panic("Invalid item in '" + peerDbName + "' database")
+		}
+
+		knownpeers.INSTANCE.AddOrUpdate(peer)
+		count++
+		plugin.LogDebug("Added stored peer: " + peer.Address.String() + " / " + peer.Identity.StringIdentifier)
+	})
+	if err != nil {
+		panic(err)
+	}
+
+	plugin.LogSuccess("Restored " + strconv.Itoa(count) + " peers from database")
+}
+
+func Configure(plugin *node.Plugin) {
+	initDb()
+
+	// do not store the entry nodes by ignoring all peers currently contained in konwnpeers
+	// add peers from db
+	loadPeers(plugin)
+
+	// subscribe to all known peers' events
+	knownpeers.INSTANCE.Events.Add.Attach(events.NewClosure(func(p *peer.Peer) {
+		storePeer(p)
+	}))
+	knownpeers.INSTANCE.Events.Update.Attach(events.NewClosure(func(p *peer.Peer) {
+		storePeer(p)
+	}))
+	knownpeers.INSTANCE.Events.Remove.Attach(events.NewClosure(func(p *peer.Peer) {
+		removePeer(p)
+	}))
+}
diff --git a/plugins/autopeering/plugin.go b/plugins/autopeering/plugin.go
index ce2a0cde4e34e3c9372170882ed0adac0b792871..c8633bffc4f2d02e21afd16fdc113e90be347bcc 100644
--- a/plugins/autopeering/plugin.go
+++ b/plugins/autopeering/plugin.go
@@ -8,6 +8,7 @@ import (
 	"github.com/iotaledger/goshimmer/plugins/autopeering/instances/acceptedneighbors"
 	"github.com/iotaledger/goshimmer/plugins/autopeering/instances/chosenneighbors"
 	"github.com/iotaledger/goshimmer/plugins/autopeering/instances/knownpeers"
+	"github.com/iotaledger/goshimmer/plugins/autopeering/peerstorage"
 	"github.com/iotaledger/goshimmer/plugins/autopeering/protocol"
 	"github.com/iotaledger/goshimmer/plugins/autopeering/saltmanager"
 	"github.com/iotaledger/goshimmer/plugins/autopeering/server"
@@ -22,6 +23,7 @@ func configure(plugin *node.Plugin) {
 	instances.Configure(plugin)
 	server.Configure(plugin)
 	protocol.Configure(plugin)
+	peerstorage.Configure(plugin)
 
 	daemon.Events.Shutdown.Attach(events.NewClosure(func() {
 		server.Shutdown(plugin)
diff --git a/plugins/autopeering/server/tcp/server.go b/plugins/autopeering/server/tcp/server.go
index 570b80754576ae4816ad1b3e5f45edbf0efd30ff..3d4977aa395efac4ca5a0326dc9bc0f54c3b87ff 100644
--- a/plugins/autopeering/server/tcp/server.go
+++ b/plugins/autopeering/server/tcp/server.go
@@ -65,7 +65,7 @@ func HandleConnection(conn *network.ManagedConnection) {
 		ProcessIncomingPacket(&connectionState, &receiveBuffer, conn, data, &offset)
 	}))
 
-	go conn.Read(make([]byte, int(math.Max(ping.MARSHALLED_TOTAL_SIZE, math.Max(request.MARSHALLED_TOTAL_SIZE, response.MARSHALLED_TOTAL_SIZE)))))
+	go conn.Read(make([]byte, int(math.Max(ping.MARSHALED_TOTAL_SIZE, math.Max(request.MARSHALED_TOTAL_SIZE, response.MARSHALED_TOTAL_SIZE)))))
 }
 
 func ProcessIncomingPacket(connectionState *byte, receiveBuffer *[]byte, conn *network.ManagedConnection, data []byte, offset *int) {
@@ -83,11 +83,11 @@ func ProcessIncomingPacket(connectionState *byte, receiveBuffer *[]byte, conn *n
 
 		switch *connectionState {
 		case STATE_REQUEST:
-			*receiveBuffer = make([]byte, request.MARSHALLED_TOTAL_SIZE)
+			*receiveBuffer = make([]byte, request.MARSHALED_TOTAL_SIZE)
 		case STATE_RESPONSE:
-			*receiveBuffer = make([]byte, response.MARSHALLED_TOTAL_SIZE)
+			*receiveBuffer = make([]byte, response.MARSHALED_TOTAL_SIZE)
 		case STATE_PING:
-			*receiveBuffer = make([]byte, ping.MARSHALLED_TOTAL_SIZE)
+			*receiveBuffer = make([]byte, ping.MARSHALED_TOTAL_SIZE)
 		}
 	}
 
@@ -106,16 +106,16 @@ func parsePackageHeader(data []byte) (byte, []byte, error) {
 	var receiveBuffer []byte
 
 	switch data[0] {
-	case request.MARSHALLED_PACKET_HEADER:
-		receiveBuffer = make([]byte, request.MARSHALLED_TOTAL_SIZE)
+	case request.MARSHALED_PACKET_HEADER:
+		receiveBuffer = make([]byte, request.MARSHALED_TOTAL_SIZE)
 
 		connectionState = STATE_REQUEST
 	case response.MARHSALLED_PACKET_HEADER:
-		receiveBuffer = make([]byte, response.MARSHALLED_TOTAL_SIZE)
+		receiveBuffer = make([]byte, response.MARSHALED_TOTAL_SIZE)
 
 		connectionState = STATE_RESPONSE
-	case ping.MARSHALLED_PACKET_HEADER:
-		receiveBuffer = make([]byte, ping.MARSHALLED_TOTAL_SIZE)
+	case ping.MARSHALED_PACKET_HEADER:
+		receiveBuffer = make([]byte, ping.MARSHALED_TOTAL_SIZE)
 
 		connectionState = STATE_PING
 	default:
@@ -126,11 +126,11 @@ func parsePackageHeader(data []byte) (byte, []byte, error) {
 }
 
 func processIncomingRequestPacket(connectionState *byte, receiveBuffer *[]byte, conn *network.ManagedConnection, data []byte, offset *int) {
-	remainingCapacity := int(math.Min(float64(request.MARSHALLED_TOTAL_SIZE-*offset), float64(len(data))))
+	remainingCapacity := int(math.Min(float64(request.MARSHALED_TOTAL_SIZE-*offset), float64(len(data))))
 
 	copy((*receiveBuffer)[*offset:], data[:remainingCapacity])
 
-	if *offset+len(data) < request.MARSHALLED_TOTAL_SIZE {
+	if *offset+len(data) < request.MARSHALED_TOTAL_SIZE {
 		*offset += len(data)
 	} else {
 		if req, err := request.Unmarshal(*receiveBuffer); err != nil {
@@ -152,18 +152,18 @@ func processIncomingRequestPacket(connectionState *byte, receiveBuffer *[]byte,
 
 		*connectionState = STATE_INITIAL
 
-		if *offset+len(data) > request.MARSHALLED_TOTAL_SIZE {
+		if *offset+len(data) > request.MARSHALED_TOTAL_SIZE {
 			ProcessIncomingPacket(connectionState, receiveBuffer, conn, data[remainingCapacity:], offset)
 		}
 	}
 }
 
 func processIncomingResponsePacket(connectionState *byte, receiveBuffer *[]byte, conn *network.ManagedConnection, data []byte, offset *int) {
-	remainingCapacity := int(math.Min(float64(response.MARSHALLED_TOTAL_SIZE-*offset), float64(len(data))))
+	remainingCapacity := int(math.Min(float64(response.MARSHALED_TOTAL_SIZE-*offset), float64(len(data))))
 
 	copy((*receiveBuffer)[*offset:], data[:remainingCapacity])
 
-	if *offset+len(data) < response.MARSHALLED_TOTAL_SIZE {
+	if *offset+len(data) < response.MARSHALED_TOTAL_SIZE {
 		*offset += len(data)
 	} else {
 		if res, err := response.Unmarshal(*receiveBuffer); err != nil {
@@ -185,18 +185,18 @@ func processIncomingResponsePacket(connectionState *byte, receiveBuffer *[]byte,
 
 		*connectionState = STATE_INITIAL
 
-		if *offset+len(data) > response.MARSHALLED_TOTAL_SIZE {
+		if *offset+len(data) > response.MARSHALED_TOTAL_SIZE {
 			ProcessIncomingPacket(connectionState, receiveBuffer, conn, data[remainingCapacity:], offset)
 		}
 	}
 }
 
 func processIncomingPingPacket(connectionState *byte, receiveBuffer *[]byte, conn *network.ManagedConnection, data []byte, offset *int) {
-	remainingCapacity := int(math.Min(float64(ping.MARSHALLED_TOTAL_SIZE-*offset), float64(len(data))))
+	remainingCapacity := int(math.Min(float64(ping.MARSHALED_TOTAL_SIZE-*offset), float64(len(data))))
 
 	copy((*receiveBuffer)[*offset:], data[:remainingCapacity])
 
-	if *offset+len(data) < ping.MARSHALLED_TOTAL_SIZE {
+	if *offset+len(data) < ping.MARSHALED_TOTAL_SIZE {
 		*offset += len(data)
 	} else {
 		if ping, err := ping.Unmarshal(*receiveBuffer); err != nil {
@@ -218,7 +218,7 @@ func processIncomingPingPacket(connectionState *byte, receiveBuffer *[]byte, con
 
 		*connectionState = STATE_INITIAL
 
-		if *offset+len(data) > ping.MARSHALLED_TOTAL_SIZE {
+		if *offset+len(data) > ping.MARSHALED_TOTAL_SIZE {
 			ProcessIncomingPacket(connectionState, receiveBuffer, conn, data[remainingCapacity:], offset)
 		}
 	}
diff --git a/plugins/autopeering/server/udp/server.go b/plugins/autopeering/server/udp/server.go
index 563a9d88bd6bb5be29019d9b0479f3b43d9b9c3f..01e66fade4fab0bad39baa0785d751511dec4189 100644
--- a/plugins/autopeering/server/udp/server.go
+++ b/plugins/autopeering/server/udp/server.go
@@ -17,7 +17,7 @@ import (
 	"github.com/pkg/errors"
 )
 
-var udpServer = udp.NewServer(int(math.Max(float64(request.MARSHALLED_TOTAL_SIZE), float64(response.MARSHALLED_TOTAL_SIZE))))
+var udpServer = udp.NewServer(int(math.Max(float64(request.MARSHALED_TOTAL_SIZE), float64(response.MARSHALED_TOTAL_SIZE))))
 
 func ConfigureServer(plugin *node.Plugin) {
 	Events.Error.Attach(events.NewClosure(func(ip net.IP, err error) {
@@ -60,7 +60,7 @@ func ShutdownUDPServer(plugin *node.Plugin) {
 
 func processReceivedData(addr *net.UDPAddr, data []byte) {
 	switch data[0] {
-	case request.MARSHALLED_PACKET_HEADER:
+	case request.MARSHALED_PACKET_HEADER:
 		if peeringRequest, err := request.Unmarshal(data); err != nil {
 			Events.Error.Trigger(addr.IP, err)
 		} else {
@@ -76,7 +76,7 @@ func processReceivedData(addr *net.UDPAddr, data []byte) {
 
 			Events.ReceiveResponse.Trigger(peeringResponse)
 		}
-	case ping.MARSHALLED_PACKET_HEADER:
+	case ping.MARSHALED_PACKET_HEADER:
 		if ping, err := ping.Unmarshal(data); err != nil {
 			Events.Error.Trigger(addr.IP, err)
 		} else {
@@ -84,7 +84,7 @@ func processReceivedData(addr *net.UDPAddr, data []byte) {
 
 			Events.ReceivePing.Trigger(ping)
 		}
-	case drop.MARSHALLED_PACKET_HEADER:
+	case drop.MARSHALED_PACKET_HEADER:
 		if drop, err := drop.Unmarshal(data); err != nil {
 			Events.Error.Trigger(addr.IP, err)
 		} else {
diff --git a/plugins/autopeering/types/drop/constants.go b/plugins/autopeering/types/drop/constants.go
index ccc3c1d60615068835bca901a118aa43b745f479..b12728d748de7ef1a1f19a3d80a8007ec1a17d7b 100644
--- a/plugins/autopeering/types/drop/constants.go
+++ b/plugins/autopeering/types/drop/constants.go
@@ -5,19 +5,19 @@ import (
 )
 
 const (
-	MARSHALLED_PACKET_HEADER = 0x05
+	MARSHALED_PACKET_HEADER = 0x05
 
-	PACKET_HEADER_START        = 0
-	MARSHALLED_ISSUER_START    = PACKET_HEADER_END
-	MARSHALLED_SIGNATURE_START = MARSHALLED_ISSUER_END
+	PACKET_HEADER_START       = 0
+	MARSHALED_ISSUER_START    = PACKET_HEADER_END
+	MARSHALED_SIGNATURE_START = MARSHALED_ISSUER_END
 
-	PACKET_HEADER_END        = PACKET_HEADER_START + PACKET_HEADER_SIZE
-	MARSHALLED_ISSUER_END    = MARSHALLED_ISSUER_START + MARSHALLED_ISSUER_SIZE
-	MARSHALLED_SIGNATURE_END = MARSHALLED_SIGNATURE_START + MARSHALLED_SIGNATURE_SIZE
+	PACKET_HEADER_END       = PACKET_HEADER_START + PACKET_HEADER_SIZE
+	MARSHALED_ISSUER_END    = MARSHALED_ISSUER_START + MARSHALED_ISSUER_SIZE
+	MARSHALED_SIGNATURE_END = MARSHALED_SIGNATURE_START + MARSHALED_SIGNATURE_SIZE
 
-	PACKET_HEADER_SIZE        = 1
-	MARSHALLED_ISSUER_SIZE    = peer.MARSHALLED_TOTAL_SIZE
-	MARSHALLED_SIGNATURE_SIZE = 65
+	PACKET_HEADER_SIZE       = 1
+	MARSHALED_ISSUER_SIZE    = peer.MARSHALED_TOTAL_SIZE
+	MARSHALED_SIGNATURE_SIZE = 65
 
-	MARSHALLED_TOTAL_SIZE = MARSHALLED_SIGNATURE_END
+	MARSHALED_TOTAL_SIZE = MARSHALED_SIGNATURE_END
 )
diff --git a/plugins/autopeering/types/drop/drop.go b/plugins/autopeering/types/drop/drop.go
index e86b5cfad5c5b4b693594a98df70e033f74c24ab..4ed249d2f4cbe46f605fd12578376d9ab397da89 100644
--- a/plugins/autopeering/types/drop/drop.go
+++ b/plugins/autopeering/types/drop/drop.go
@@ -10,49 +10,49 @@ import (
 
 type Drop struct {
 	Issuer    *peer.Peer
-	Signature [MARSHALLED_SIGNATURE_SIZE]byte
+	Signature [MARSHALED_SIGNATURE_SIZE]byte
 }
 
 func Unmarshal(data []byte) (*Drop, error) {
-	if data[0] != MARSHALLED_PACKET_HEADER || len(data) != MARSHALLED_TOTAL_SIZE {
+	if data[0] != MARSHALED_PACKET_HEADER || len(data) != MARSHALED_TOTAL_SIZE {
 		return nil, ErrMalformedDropMessage
 	}
 
 	ping := &Drop{}
 
-	if unmarshalledPeer, err := peer.Unmarshal(data[MARSHALLED_ISSUER_START:MARSHALLED_ISSUER_END]); err != nil {
+	if unmarshaledPeer, err := peer.Unmarshal(data[MARSHALED_ISSUER_START:MARSHALED_ISSUER_END]); err != nil {
 		return nil, err
 	} else {
-		ping.Issuer = unmarshalledPeer
+		ping.Issuer = unmarshaledPeer
 	}
 	if err := saltmanager.CheckSalt(ping.Issuer.Salt); err != nil {
 		return nil, err
 	}
 
-	if issuer, err := identity.FromSignedData(data[:MARSHALLED_SIGNATURE_START], data[MARSHALLED_SIGNATURE_START:]); err != nil {
+	if issuer, err := identity.FromSignedData(data[:MARSHALED_SIGNATURE_START], data[MARSHALED_SIGNATURE_START:]); err != nil {
 		return nil, err
 	} else {
 		if !bytes.Equal(issuer.Identifier, ping.Issuer.Identity.Identifier) {
 			return nil, ErrInvalidSignature
 		}
 	}
-	copy(ping.Signature[:], data[MARSHALLED_SIGNATURE_START:MARSHALLED_SIGNATURE_END])
+	copy(ping.Signature[:], data[MARSHALED_SIGNATURE_START:MARSHALED_SIGNATURE_END])
 
 	return ping, nil
 }
 
 func (ping *Drop) Marshal() []byte {
-	result := make([]byte, MARSHALLED_TOTAL_SIZE)
+	result := make([]byte, MARSHALED_TOTAL_SIZE)
 
-	result[PACKET_HEADER_START] = MARSHALLED_PACKET_HEADER
-	copy(result[MARSHALLED_ISSUER_START:MARSHALLED_ISSUER_END], ping.Issuer.Marshal())
-	copy(result[MARSHALLED_SIGNATURE_START:MARSHALLED_SIGNATURE_END], ping.Signature[:MARSHALLED_SIGNATURE_SIZE])
+	result[PACKET_HEADER_START] = MARSHALED_PACKET_HEADER
+	copy(result[MARSHALED_ISSUER_START:MARSHALED_ISSUER_END], ping.Issuer.Marshal())
+	copy(result[MARSHALED_SIGNATURE_START:MARSHALED_SIGNATURE_END], ping.Signature[:MARSHALED_SIGNATURE_SIZE])
 
 	return result
 }
 
 func (this *Drop) Sign() {
-	if signature, err := this.Issuer.Identity.Sign(this.Marshal()[:MARSHALLED_SIGNATURE_START]); err != nil {
+	if signature, err := this.Issuer.Identity.Sign(this.Marshal()[:MARSHALED_SIGNATURE_START]); err != nil {
 		panic(err)
 	} else {
 		copy(this.Signature[:], signature)
diff --git a/plugins/autopeering/types/peer/constants.go b/plugins/autopeering/types/peer/constants.go
index 28e0461127f5405e414b1c6cd52373747432ffd9..1abfe1077276d1af817476f31324fa1710515f9e 100644
--- a/plugins/autopeering/types/peer/constants.go
+++ b/plugins/autopeering/types/peer/constants.go
@@ -6,25 +6,25 @@ import (
 )
 
 const (
-	MARSHALLED_PUBLIC_KEY_START   = 0
-	MARSHALLED_ADDRESS_TYPE_START = MARSHALLED_PUBLIC_KEY_END
-	MARSHALLED_ADDRESS_START      = MARSHALLED_ADDRESS_TYPE_END
-	MARSHALLED_PEERING_PORT_START = MARSHALLED_ADDRESS_END
-	MARSHALLED_GOSSIP_PORT_START  = MARSHALLED_PEERING_PORT_END
-	MARSHALLED_SALT_START         = MARSHALLED_GOSSIP_PORT_END
+	MARSHALED_PUBLIC_KEY_START   = 0
+	MARSHALED_ADDRESS_TYPE_START = MARSHALED_PUBLIC_KEY_END
+	MARSHALED_ADDRESS_START      = MARSHALED_ADDRESS_TYPE_END
+	MARSHALED_PEERING_PORT_START = MARSHALED_ADDRESS_END
+	MARSHALED_GOSSIP_PORT_START  = MARSHALED_PEERING_PORT_END
+	MARSHALED_SALT_START         = MARSHALED_GOSSIP_PORT_END
 
-	MARSHALLED_PUBLIC_KEY_END   = MARSHALLED_PUBLIC_KEY_START + MARSHALLED_PUBLIC_KEY_SIZE
-	MARSHALLED_ADDRESS_TYPE_END = MARSHALLED_ADDRESS_TYPE_START + MARSHALLED_ADDRESS_TYPE_SIZE
-	MARSHALLED_ADDRESS_END      = MARSHALLED_ADDRESS_START + MARSHALLED_ADDRESS_SIZE
-	MARSHALLED_PEERING_PORT_END = MARSHALLED_PEERING_PORT_START + MARSHALLED_PEERING_PORT_SIZE
-	MARSHALLED_GOSSIP_PORT_END  = MARSHALLED_GOSSIP_PORT_START + MARSHALLED_GOSSIP_PORT_SIZE
-	MARSHALLED_SALT_END         = MARSHALLED_SALT_START + MARSHALLED_SALT_SIZE
+	MARSHALED_PUBLIC_KEY_END   = MARSHALED_PUBLIC_KEY_START + MARSHALED_PUBLIC_KEY_SIZE
+	MARSHALED_ADDRESS_TYPE_END = MARSHALED_ADDRESS_TYPE_START + MARSHALED_ADDRESS_TYPE_SIZE
+	MARSHALED_ADDRESS_END      = MARSHALED_ADDRESS_START + MARSHALED_ADDRESS_SIZE
+	MARSHALED_PEERING_PORT_END = MARSHALED_PEERING_PORT_START + MARSHALED_PEERING_PORT_SIZE
+	MARSHALED_GOSSIP_PORT_END  = MARSHALED_GOSSIP_PORT_START + MARSHALED_GOSSIP_PORT_SIZE
+	MARSHALED_SALT_END         = MARSHALED_SALT_START + MARSHALED_SALT_SIZE
 
-	MARSHALLED_PUBLIC_KEY_SIZE   = identity.PUBLIC_KEY_BYTE_LENGTH
-	MARSHALLED_ADDRESS_TYPE_SIZE = 1
-	MARSHALLED_ADDRESS_SIZE      = 16
-	MARSHALLED_PEERING_PORT_SIZE = 2
-	MARSHALLED_GOSSIP_PORT_SIZE  = 2
-	MARSHALLED_SALT_SIZE         = salt.SALT_MARSHALLED_SIZE
-	MARSHALLED_TOTAL_SIZE        = MARSHALLED_SALT_END
+	MARSHALED_PUBLIC_KEY_SIZE   = identity.PUBLIC_KEY_BYTE_LENGTH
+	MARSHALED_ADDRESS_TYPE_SIZE = 1
+	MARSHALED_ADDRESS_SIZE      = 16
+	MARSHALED_PEERING_PORT_SIZE = 2
+	MARSHALED_GOSSIP_PORT_SIZE  = 2
+	MARSHALED_SALT_SIZE         = salt.SALT_MARSHALED_SIZE
+	MARSHALED_TOTAL_SIZE        = MARSHALED_SALT_END
 )
diff --git a/plugins/autopeering/types/peer/peer.go b/plugins/autopeering/types/peer/peer.go
index bd3605d868712fe77d71a7333f2d8dc4a772084a..9bc8510cf4fc9bfe7f171392983b7735e9e340d5 100644
--- a/plugins/autopeering/types/peer/peer.go
+++ b/plugins/autopeering/types/peer/peer.go
@@ -25,28 +25,28 @@ type Peer struct {
 }
 
 func Unmarshal(data []byte) (*Peer, error) {
-	if len(data) < MARSHALLED_TOTAL_SIZE {
-		return nil, errors.New("size of marshalled peer is too small")
+	if len(data) < MARSHALED_TOTAL_SIZE {
+		return nil, errors.New("size of marshaled peer is too small")
 	}
 
 	peer := &Peer{
-		Identity: identity.NewIdentity(data[MARSHALLED_PUBLIC_KEY_START:MARSHALLED_PUBLIC_KEY_END]),
+		Identity: identity.NewIdentity(data[MARSHALED_PUBLIC_KEY_START:MARSHALED_PUBLIC_KEY_END]),
 	}
 
-	switch data[MARSHALLED_ADDRESS_TYPE_START] {
+	switch data[MARSHALED_ADDRESS_TYPE_START] {
 	case types.ADDRESS_TYPE_IPV4:
-		peer.Address = net.IP(data[MARSHALLED_ADDRESS_START:MARSHALLED_ADDRESS_END]).To4()
+		peer.Address = net.IP(data[MARSHALED_ADDRESS_START:MARSHALED_ADDRESS_END]).To4()
 	case types.ADDRESS_TYPE_IPV6:
-		peer.Address = net.IP(data[MARSHALLED_ADDRESS_START:MARSHALLED_ADDRESS_END]).To16()
+		peer.Address = net.IP(data[MARSHALED_ADDRESS_START:MARSHALED_ADDRESS_END]).To16()
 	}
 
-	peer.PeeringPort = binary.BigEndian.Uint16(data[MARSHALLED_PEERING_PORT_START:MARSHALLED_PEERING_PORT_END])
-	peer.GossipPort = binary.BigEndian.Uint16(data[MARSHALLED_GOSSIP_PORT_START:MARSHALLED_GOSSIP_PORT_END])
+	peer.PeeringPort = binary.BigEndian.Uint16(data[MARSHALED_PEERING_PORT_START:MARSHALED_PEERING_PORT_END])
+	peer.GossipPort = binary.BigEndian.Uint16(data[MARSHALED_GOSSIP_PORT_START:MARSHALED_GOSSIP_PORT_END])
 
-	if unmarshalledSalt, err := salt.Unmarshal(data[MARSHALLED_SALT_START:MARSHALLED_SALT_END]); err != nil {
+	if unmarshaledSalt, err := salt.Unmarshal(data[MARSHALED_SALT_START:MARSHALED_SALT_END]); err != nil {
 		return nil, err
 	} else {
-		peer.Salt = unmarshalledSalt
+		peer.Salt = unmarshaledSalt
 	}
 
 	return peer, nil
@@ -115,26 +115,26 @@ func (peer *Peer) Connect(protocol types.ProtocolType) (*network.ManagedConnecti
 }
 
 func (peer *Peer) Marshal() []byte {
-	result := make([]byte, MARSHALLED_TOTAL_SIZE)
+	result := make([]byte, MARSHALED_TOTAL_SIZE)
 
-	copy(result[MARSHALLED_PUBLIC_KEY_START:MARSHALLED_PUBLIC_KEY_END],
-		peer.Identity.PublicKey[:MARSHALLED_PUBLIC_KEY_SIZE])
+	copy(result[MARSHALED_PUBLIC_KEY_START:MARSHALED_PUBLIC_KEY_END],
+		peer.Identity.PublicKey[:MARSHALED_PUBLIC_KEY_SIZE])
 
 	switch len(peer.Address) {
 	case net.IPv4len:
-		result[MARSHALLED_ADDRESS_TYPE_START] = types.ADDRESS_TYPE_IPV4
+		result[MARSHALED_ADDRESS_TYPE_START] = types.ADDRESS_TYPE_IPV4
 	case net.IPv6len:
-		result[MARSHALLED_ADDRESS_TYPE_START] = types.ADDRESS_TYPE_IPV6
+		result[MARSHALED_ADDRESS_TYPE_START] = types.ADDRESS_TYPE_IPV6
 	default:
 		panic("invalid address in peer")
 	}
 
-	copy(result[MARSHALLED_ADDRESS_START:MARSHALLED_ADDRESS_END], peer.Address.To16())
+	copy(result[MARSHALED_ADDRESS_START:MARSHALED_ADDRESS_END], peer.Address.To16())
 
-	binary.BigEndian.PutUint16(result[MARSHALLED_PEERING_PORT_START:MARSHALLED_PEERING_PORT_END], peer.PeeringPort)
-	binary.BigEndian.PutUint16(result[MARSHALLED_GOSSIP_PORT_START:MARSHALLED_GOSSIP_PORT_END], peer.GossipPort)
+	binary.BigEndian.PutUint16(result[MARSHALED_PEERING_PORT_START:MARSHALED_PEERING_PORT_END], peer.PeeringPort)
+	binary.BigEndian.PutUint16(result[MARSHALED_GOSSIP_PORT_START:MARSHALED_GOSSIP_PORT_END], peer.GossipPort)
 
-	copy(result[MARSHALLED_SALT_START:MARSHALLED_SALT_END], peer.Salt.Marshal())
+	copy(result[MARSHALED_SALT_START:MARSHALED_SALT_END], peer.Salt.Marshal())
 
 	return result
 }
diff --git a/plugins/autopeering/types/peerregister/peer_register.go b/plugins/autopeering/types/peerregister/peer_register.go
index abb97e52c96669afc18bc150f1c377a28a233ba1..b90608dd84d1063e2352002af1109da3bd813a09 100644
--- a/plugins/autopeering/types/peerregister/peer_register.go
+++ b/plugins/autopeering/types/peerregister/peer_register.go
@@ -42,6 +42,12 @@ func (this *PeerRegister) AddOrUpdate(peer *peer.Peer, lock ...bool) bool {
 		existingPeer.Address = peer.Address
 		existingPeer.GossipPort = peer.GossipPort
 		existingPeer.PeeringPort = peer.PeeringPort
+		existingPeer.Salt = peer.Salt
+
+		// also update the public key if not yet present
+		if existingPeer.Identity.PublicKey == nil {
+			existingPeer.Identity.PublicKey = peer.Identity.PublicKey
+		}
 
 		this.Events.Update.Trigger(existingPeer)
 
diff --git a/plugins/autopeering/types/ping/constants.go b/plugins/autopeering/types/ping/constants.go
index 6d37911b040aec78350655f6f90e96a0409af76a..22b17d9d54a0c8cbf6d851cb7d5e39a68e8a0c17 100644
--- a/plugins/autopeering/types/ping/constants.go
+++ b/plugins/autopeering/types/ping/constants.go
@@ -6,24 +6,24 @@ import (
 )
 
 const (
-	MARSHALLED_PACKET_HEADER = 0x04
+	MARSHALED_PACKET_HEADER = 0x04
 
-	PACKET_HEADER_START        = 0
-	MARSHALLED_ISSUER_START    = PACKET_HEADER_END
-	MARSHALLED_PEERS_START     = MARSHALLED_ISSUER_END
-	MARSHALLED_SIGNATURE_START = MARSHALLED_PEERS_END
+	PACKET_HEADER_START       = 0
+	MARSHALED_ISSUER_START    = PACKET_HEADER_END
+	MARSHALED_PEERS_START     = MARSHALED_ISSUER_END
+	MARSHALED_SIGNATURE_START = MARSHALED_PEERS_END
 
-	PACKET_HEADER_END        = PACKET_HEADER_START + PACKET_HEADER_SIZE
-	MARSHALLED_ISSUER_END    = MARSHALLED_ISSUER_START + MARSHALLED_ISSUER_SIZE
-	MARSHALLED_PEERS_END     = MARSHALLED_PEERS_START + MARSHALLED_PEERS_SIZE
-	MARSHALLED_SIGNATURE_END = MARSHALLED_SIGNATURE_START + MARSHALLED_SIGNATURE_SIZE
+	PACKET_HEADER_END       = PACKET_HEADER_START + PACKET_HEADER_SIZE
+	MARSHALED_ISSUER_END    = MARSHALED_ISSUER_START + MARSHALED_ISSUER_SIZE
+	MARSHALED_PEERS_END     = MARSHALED_PEERS_START + MARSHALED_PEERS_SIZE
+	MARSHALED_SIGNATURE_END = MARSHALED_SIGNATURE_START + MARSHALED_SIGNATURE_SIZE
 
-	PACKET_HEADER_SIZE              = 1
-	MARSHALLED_ISSUER_SIZE          = peer.MARSHALLED_TOTAL_SIZE
-	MARSHALLED_PEER_ENTRY_FLAG_SIZE = 1
-	MARSHALLED_PEER_ENTRY_SIZE      = MARSHALLED_PEER_ENTRY_FLAG_SIZE + peer.MARSHALLED_TOTAL_SIZE
-	MARSHALLED_PEERS_SIZE           = MARSHALLED_PEER_ENTRY_SIZE * constants.NEIGHBOR_COUNT
-	MARSHALLED_SIGNATURE_SIZE       = 65
+	PACKET_HEADER_SIZE             = 1
+	MARSHALED_ISSUER_SIZE          = peer.MARSHALED_TOTAL_SIZE
+	MARSHALED_PEER_ENTRY_FLAG_SIZE = 1
+	MARSHALED_PEER_ENTRY_SIZE      = MARSHALED_PEER_ENTRY_FLAG_SIZE + peer.MARSHALED_TOTAL_SIZE
+	MARSHALED_PEERS_SIZE           = MARSHALED_PEER_ENTRY_SIZE * constants.NEIGHBOR_COUNT
+	MARSHALED_SIGNATURE_SIZE       = 65
 
-	MARSHALLED_TOTAL_SIZE = MARSHALLED_SIGNATURE_END
+	MARSHALED_TOTAL_SIZE = MARSHALED_SIGNATURE_END
 )
diff --git a/plugins/autopeering/types/ping/ping.go b/plugins/autopeering/types/ping/ping.go
index 3153d66034e37b0cf9e61141372bd1cd2ad69f83..a658af1541a74933283ed4fde294430e31ea7b9e 100644
--- a/plugins/autopeering/types/ping/ping.go
+++ b/plugins/autopeering/types/ping/ping.go
@@ -13,11 +13,11 @@ import (
 type Ping struct {
 	Issuer    *peer.Peer
 	Neighbors peerlist.PeerList
-	Signature [MARSHALLED_SIGNATURE_SIZE]byte
+	Signature [MARSHALED_SIGNATURE_SIZE]byte
 }
 
 func Unmarshal(data []byte) (*Ping, error) {
-	if data[0] != MARSHALLED_PACKET_HEADER || len(data) != MARSHALLED_TOTAL_SIZE {
+	if data[0] != MARSHALED_PACKET_HEADER || len(data) != MARSHALED_TOTAL_SIZE {
 		return nil, ErrMalformedPing
 	}
 
@@ -25,59 +25,59 @@ func Unmarshal(data []byte) (*Ping, error) {
 		Neighbors: make(peerlist.PeerList, 0),
 	}
 
-	if unmarshalledPeer, err := peer.Unmarshal(data[MARSHALLED_ISSUER_START:MARSHALLED_ISSUER_END]); err != nil {
+	if unmarshaledPeer, err := peer.Unmarshal(data[MARSHALED_ISSUER_START:MARSHALED_ISSUER_END]); err != nil {
 		return nil, err
 	} else {
-		ping.Issuer = unmarshalledPeer
+		ping.Issuer = unmarshaledPeer
 	}
 	if err := saltmanager.CheckSalt(ping.Issuer.Salt); err != nil {
 		return nil, err
 	}
 
-	offset := MARSHALLED_PEERS_START
+	offset := MARSHALED_PEERS_START
 	for i := 0; i < constants.NEIGHBOR_COUNT; i++ {
 		if data[offset] == 1 {
-			if unmarshalledPing, err := peer.Unmarshal(data[offset+1 : offset+MARSHALLED_PEER_ENTRY_SIZE]); err != nil {
+			if unmarshaledPing, err := peer.Unmarshal(data[offset+1 : offset+MARSHALED_PEER_ENTRY_SIZE]); err != nil {
 				return nil, err
 			} else {
-				ping.Neighbors = append(ping.Neighbors, unmarshalledPing)
+				ping.Neighbors = append(ping.Neighbors, unmarshaledPing)
 			}
 		}
 
-		offset += MARSHALLED_PEER_ENTRY_SIZE
+		offset += MARSHALED_PEER_ENTRY_SIZE
 	}
 
-	if issuer, err := identity.FromSignedData(data[:MARSHALLED_SIGNATURE_START], data[MARSHALLED_SIGNATURE_START:]); err != nil {
+	if issuer, err := identity.FromSignedData(data[:MARSHALED_SIGNATURE_START], data[MARSHALED_SIGNATURE_START:]); err != nil {
 		return nil, err
 	} else {
 		if !bytes.Equal(issuer.Identifier, ping.Issuer.Identity.Identifier) {
 			return nil, ErrInvalidSignature
 		}
 	}
-	copy(ping.Signature[:], data[MARSHALLED_SIGNATURE_START:MARSHALLED_SIGNATURE_END])
+	copy(ping.Signature[:], data[MARSHALED_SIGNATURE_START:MARSHALED_SIGNATURE_END])
 
 	return ping, nil
 }
 
 func (ping *Ping) Marshal() []byte {
-	result := make([]byte, MARSHALLED_TOTAL_SIZE)
+	result := make([]byte, MARSHALED_TOTAL_SIZE)
 
-	result[PACKET_HEADER_START] = MARSHALLED_PACKET_HEADER
-	copy(result[MARSHALLED_ISSUER_START:MARSHALLED_ISSUER_END], ping.Issuer.Marshal())
+	result[PACKET_HEADER_START] = MARSHALED_PACKET_HEADER
+	copy(result[MARSHALED_ISSUER_START:MARSHALED_ISSUER_END], ping.Issuer.Marshal())
 	for i, neighbor := range ping.Neighbors {
-		entryStartOffset := MARSHALLED_PEERS_START + i*MARSHALLED_PEER_ENTRY_SIZE
+		entryStartOffset := MARSHALED_PEERS_START + i*MARSHALED_PEER_ENTRY_SIZE
 
 		result[entryStartOffset] = 1
 
-		copy(result[entryStartOffset+1:entryStartOffset+MARSHALLED_PEER_ENTRY_SIZE], neighbor.Marshal())
+		copy(result[entryStartOffset+1:entryStartOffset+MARSHALED_PEER_ENTRY_SIZE], neighbor.Marshal())
 	}
-	copy(result[MARSHALLED_SIGNATURE_START:MARSHALLED_SIGNATURE_END], ping.Signature[:MARSHALLED_SIGNATURE_SIZE])
+	copy(result[MARSHALED_SIGNATURE_START:MARSHALED_SIGNATURE_END], ping.Signature[:MARSHALED_SIGNATURE_SIZE])
 
 	return result
 }
 
 func (this *Ping) Sign() {
-	if signature, err := this.Issuer.Identity.Sign(this.Marshal()[:MARSHALLED_SIGNATURE_START]); err != nil {
+	if signature, err := this.Issuer.Identity.Sign(this.Marshal()[:MARSHALED_SIGNATURE_START]); err != nil {
 		panic(err)
 	} else {
 		copy(this.Signature[:], signature)
diff --git a/plugins/autopeering/types/request/constants.go b/plugins/autopeering/types/request/constants.go
index c70d8427768f1fa52fa52b94dc52183b8b3284fd..c1e707153f828214885a945585ce98017665b8f7 100644
--- a/plugins/autopeering/types/request/constants.go
+++ b/plugins/autopeering/types/request/constants.go
@@ -6,7 +6,7 @@ import (
 
 const (
 	PACKET_HEADER_SIZE = 1
-	ISSUER_SIZE        = peer.MARSHALLED_TOTAL_SIZE
+	ISSUER_SIZE        = peer.MARSHALED_TOTAL_SIZE
 	SIGNATURE_SIZE     = 65
 
 	PACKET_HEADER_START = 0
@@ -17,7 +17,7 @@ const (
 	ISSUER_END        = ISSUER_START + ISSUER_SIZE
 	SIGNATURE_END     = SIGNATURE_START + SIGNATURE_SIZE
 
-	MARSHALLED_TOTAL_SIZE = SIGNATURE_END
+	MARSHALED_TOTAL_SIZE = SIGNATURE_END
 
-	MARSHALLED_PACKET_HEADER = 0xBE
+	MARSHALED_PACKET_HEADER = 0xBE
 )
diff --git a/plugins/autopeering/types/request/request.go b/plugins/autopeering/types/request/request.go
index 139765485b7d48379ce2c1c91a2815c923d03384..1fa6a956b289ae16c4f53fcd55f28dbee691d0e3 100644
--- a/plugins/autopeering/types/request/request.go
+++ b/plugins/autopeering/types/request/request.go
@@ -18,16 +18,16 @@ type Request struct {
 }
 
 func Unmarshal(data []byte) (*Request, error) {
-	if data[0] != MARSHALLED_PACKET_HEADER || len(data) != MARSHALLED_TOTAL_SIZE {
+	if data[0] != MARSHALED_PACKET_HEADER || len(data) != MARSHALED_TOTAL_SIZE {
 		return nil, ErrMalformedPeeringRequest
 	}
 
 	peeringRequest := &Request{}
 
-	if unmarshalledPeer, err := peer.Unmarshal(data[ISSUER_START:ISSUER_END]); err != nil {
+	if unmarshaledPeer, err := peer.Unmarshal(data[ISSUER_START:ISSUER_END]); err != nil {
 		return nil, err
 	} else {
-		peeringRequest.Issuer = unmarshalledPeer
+		peeringRequest.Issuer = unmarshaledPeer
 	}
 
 	now := time.Now()
@@ -89,9 +89,9 @@ func (this *Request) Sign() {
 }
 
 func (this *Request) Marshal() []byte {
-	result := make([]byte, MARSHALLED_TOTAL_SIZE)
+	result := make([]byte, MARSHALED_TOTAL_SIZE)
 
-	result[PACKET_HEADER_START] = MARSHALLED_PACKET_HEADER
+	result[PACKET_HEADER_START] = MARSHALED_PACKET_HEADER
 	copy(result[ISSUER_START:ISSUER_END], this.Issuer.Marshal())
 	copy(result[SIGNATURE_START:SIGNATURE_END], this.Signature[:SIGNATURE_SIZE])
 
diff --git a/plugins/autopeering/types/response/constants.go b/plugins/autopeering/types/response/constants.go
index b5f8db127ab8b0a522d0fbfde05f9d671431acea..9ef796feee6130ba89aba3c65da081bc89736264 100644
--- a/plugins/autopeering/types/response/constants.go
+++ b/plugins/autopeering/types/response/constants.go
@@ -9,27 +9,27 @@ const (
 	TYPE_REJECT = Type(0)
 	TYPE_ACCEPT = Type(1)
 
-	MARSHALLED_PEERS_AMOUNT  = constants.NEIGHBOR_COUNT + constants.NEIGHBOR_COUNT*constants.NEIGHBOR_COUNT
+	MARSHALED_PEERS_AMOUNT   = constants.NEIGHBOR_COUNT + constants.NEIGHBOR_COUNT*constants.NEIGHBOR_COUNT
 	MARHSALLED_PACKET_HEADER = 0xBC
 
-	MARSHALLED_PACKET_HEADER_START = 0
-	MARSHALLED_TYPE_START          = MARSHALLED_PACKET_HEADER_END
-	MARSHALLED_ISSUER_START        = MARSHALLED_TYPE_END
-	MARSHALLED_PEERS_START         = MARSHALLED_ISSUER_END
-	MARSHALLED_SIGNATURE_START     = MARSHALLED_PEERS_END
+	MARSHALED_PACKET_HEADER_START = 0
+	MARSHALED_TYPE_START          = MARSHALED_PACKET_HEADER_END
+	MARSHALED_ISSUER_START        = MARSHALED_TYPE_END
+	MARSHALED_PEERS_START         = MARSHALED_ISSUER_END
+	MARSHALED_SIGNATURE_START     = MARSHALED_PEERS_END
 
-	MARSHALLED_PACKET_HEADER_END = MARSHALLED_PACKET_HEADER_START + MARSHALLED_PACKET_HEADER_SIZE
-	MARSHALLED_TYPE_END          = MARSHALLED_TYPE_START + MARSHALLED_TYPE_SIZE
-	MARSHALLED_PEERS_END         = MARSHALLED_PEERS_START + MARSHALLED_PEERS_SIZE
-	MARSHALLED_ISSUER_END        = MARSHALLED_ISSUER_START + MARSHALLED_ISSUER_SIZE
-	MARSHALLED_SIGNATURE_END     = MARSHALLED_SIGNATURE_START + MARSHALLED_SIGNATURE_SIZE
+	MARSHALED_PACKET_HEADER_END = MARSHALED_PACKET_HEADER_START + MARSHALED_PACKET_HEADER_SIZE
+	MARSHALED_TYPE_END          = MARSHALED_TYPE_START + MARSHALED_TYPE_SIZE
+	MARSHALED_PEERS_END         = MARSHALED_PEERS_START + MARSHALED_PEERS_SIZE
+	MARSHALED_ISSUER_END        = MARSHALED_ISSUER_START + MARSHALED_ISSUER_SIZE
+	MARSHALED_SIGNATURE_END     = MARSHALED_SIGNATURE_START + MARSHALED_SIGNATURE_SIZE
 
-	MARSHALLED_PACKET_HEADER_SIZE = 1
-	MARSHALLED_TYPE_SIZE          = 1
-	MARSHALLED_ISSUER_SIZE        = peer.MARSHALLED_TOTAL_SIZE
-	MARSHALLED_PEER_FLAG_SIZE     = 1
-	MARSHALLED_PEER_SIZE          = MARSHALLED_PEER_FLAG_SIZE + peer.MARSHALLED_TOTAL_SIZE
-	MARSHALLED_PEERS_SIZE         = MARSHALLED_PEERS_AMOUNT * MARSHALLED_PEER_SIZE
-	MARSHALLED_SIGNATURE_SIZE     = 65
-	MARSHALLED_TOTAL_SIZE         = MARSHALLED_SIGNATURE_END
+	MARSHALED_PACKET_HEADER_SIZE = 1
+	MARSHALED_TYPE_SIZE          = 1
+	MARSHALED_ISSUER_SIZE        = peer.MARSHALED_TOTAL_SIZE
+	MARSHALED_PEER_FLAG_SIZE     = 1
+	MARSHALED_PEER_SIZE          = MARSHALED_PEER_FLAG_SIZE + peer.MARSHALED_TOTAL_SIZE
+	MARSHALED_PEERS_SIZE         = MARSHALED_PEERS_AMOUNT * MARSHALED_PEER_SIZE
+	MARSHALED_SIGNATURE_SIZE     = 65
+	MARSHALED_TOTAL_SIZE         = MARSHALED_SIGNATURE_END
 )
diff --git a/plugins/autopeering/types/response/response.go b/plugins/autopeering/types/response/response.go
index 7d75b6e0a3c0c26b142648698dfe27d6f6e9ca6c..9ebf489541bb1fbe12c1a70434750232b9b0f12f 100644
--- a/plugins/autopeering/types/response/response.go
+++ b/plugins/autopeering/types/response/response.go
@@ -13,31 +13,31 @@ type Response struct {
 	Type      Type
 	Issuer    *peer.Peer
 	Peers     []*peer.Peer
-	Signature [MARSHALLED_SIGNATURE_SIZE]byte
+	Signature [MARSHALED_SIGNATURE_SIZE]byte
 }
 
 func Unmarshal(data []byte) (*Response, error) {
-	if data[0] != MARHSALLED_PACKET_HEADER || len(data) < MARSHALLED_TOTAL_SIZE {
+	if data[0] != MARHSALLED_PACKET_HEADER || len(data) < MARSHALED_TOTAL_SIZE {
 		return nil, errors.New("malformed peering response")
 	}
 
 	peeringResponse := &Response{
-		Type:  data[MARSHALLED_TYPE_START],
+		Type:  data[MARSHALED_TYPE_START],
 		Peers: make([]*peer.Peer, 0),
 	}
 
-	if unmarshalledPeer, err := peer.Unmarshal(data[MARSHALLED_ISSUER_START:MARSHALLED_ISSUER_END]); err != nil {
+	if unmarshaledPeer, err := peer.Unmarshal(data[MARSHALED_ISSUER_START:MARSHALED_ISSUER_END]); err != nil {
 		return nil, err
 	} else {
-		peeringResponse.Issuer = unmarshalledPeer
+		peeringResponse.Issuer = unmarshaledPeer
 	}
 
-	for i := 0; i < MARSHALLED_PEERS_AMOUNT; i++ {
-		PEERING_RESPONSE_MARSHALLED_PEER_START := MARSHALLED_PEERS_START + (i * MARSHALLED_PEER_SIZE)
-		PEERING_RESPONSE_MARSHALLED_PEER_END := PEERING_RESPONSE_MARSHALLED_PEER_START + MARSHALLED_PEER_SIZE
+	for i := 0; i < MARSHALED_PEERS_AMOUNT; i++ {
+		PEERING_RESPONSE_MARSHALED_PEER_START := MARSHALED_PEERS_START + (i * MARSHALED_PEER_SIZE)
+		PEERING_RESPONSE_MARSHALED_PEER_END := PEERING_RESPONSE_MARSHALED_PEER_START + MARSHALED_PEER_SIZE
 
-		if data[PEERING_RESPONSE_MARSHALLED_PEER_START] == 1 {
-			peer, err := peer.Unmarshal(data[PEERING_RESPONSE_MARSHALLED_PEER_START+1 : PEERING_RESPONSE_MARSHALLED_PEER_END])
+		if data[PEERING_RESPONSE_MARSHALED_PEER_START] == 1 {
+			peer, err := peer.Unmarshal(data[PEERING_RESPONSE_MARSHALED_PEER_START+1 : PEERING_RESPONSE_MARSHALED_PEER_END])
 			if err != nil {
 				return nil, err
 			}
@@ -46,20 +46,20 @@ func Unmarshal(data []byte) (*Response, error) {
 		}
 	}
 
-	if issuer, err := identity.FromSignedData(data[:MARSHALLED_SIGNATURE_START], data[MARSHALLED_SIGNATURE_START:]); err != nil {
+	if issuer, err := identity.FromSignedData(data[:MARSHALED_SIGNATURE_START], data[MARSHALED_SIGNATURE_START:]); err != nil {
 		return nil, err
 	} else {
 		if !bytes.Equal(issuer.Identifier, peeringResponse.Issuer.Identity.Identifier) {
 			return nil, ErrInvalidSignature
 		}
 	}
-	copy(peeringResponse.Signature[:], data[MARSHALLED_SIGNATURE_START:MARSHALLED_SIGNATURE_END])
+	copy(peeringResponse.Signature[:], data[MARSHALED_SIGNATURE_START:MARSHALED_SIGNATURE_END])
 
 	return peeringResponse, nil
 }
 
 func (this *Response) Sign() *Response {
-	dataToSign := this.Marshal()[:MARSHALLED_SIGNATURE_START]
+	dataToSign := this.Marshal()[:MARSHALED_SIGNATURE_START]
 	if signature, err := this.Issuer.Identity.Sign(dataToSign); err != nil {
 		panic(err)
 	} else {
@@ -70,24 +70,24 @@ func (this *Response) Sign() *Response {
 }
 
 func (this *Response) Marshal() []byte {
-	result := make([]byte, MARSHALLED_TOTAL_SIZE)
+	result := make([]byte, MARSHALED_TOTAL_SIZE)
 
-	result[MARSHALLED_PACKET_HEADER_START] = MARHSALLED_PACKET_HEADER
-	result[MARSHALLED_TYPE_START] = this.Type
+	result[MARSHALED_PACKET_HEADER_START] = MARHSALLED_PACKET_HEADER
+	result[MARSHALED_TYPE_START] = this.Type
 
-	copy(result[MARSHALLED_ISSUER_START:MARSHALLED_ISSUER_END], this.Issuer.Marshal())
+	copy(result[MARSHALED_ISSUER_START:MARSHALED_ISSUER_END], this.Issuer.Marshal())
 
 	for i, peer := range this.Peers {
 		if i < constants.NEIGHBOR_COUNT {
-			PEERING_RESPONSE_MARSHALLED_PEER_START := MARSHALLED_PEERS_START + (i * MARSHALLED_PEER_SIZE)
-			PEERING_RESPONSE_MARSHALLED_PEER_END := PEERING_RESPONSE_MARSHALLED_PEER_START + MARSHALLED_PEER_SIZE
+			PEERING_RESPONSE_MARSHALED_PEER_START := MARSHALED_PEERS_START + (i * MARSHALED_PEER_SIZE)
+			PEERING_RESPONSE_MARSHALED_PEER_END := PEERING_RESPONSE_MARSHALED_PEER_START + MARSHALED_PEER_SIZE
 
-			result[PEERING_RESPONSE_MARSHALLED_PEER_START] = 1
-			copy(result[PEERING_RESPONSE_MARSHALLED_PEER_START+1:PEERING_RESPONSE_MARSHALLED_PEER_END], peer.Marshal()[:MARSHALLED_PEER_SIZE-1])
+			result[PEERING_RESPONSE_MARSHALED_PEER_START] = 1
+			copy(result[PEERING_RESPONSE_MARSHALED_PEER_START+1:PEERING_RESPONSE_MARSHALED_PEER_END], peer.Marshal()[:MARSHALED_PEER_SIZE-1])
 		}
 	}
 
-	copy(result[MARSHALLED_SIGNATURE_START:MARSHALLED_SIGNATURE_END], this.Signature[:MARSHALLED_SIGNATURE_SIZE])
+	copy(result[MARSHALED_SIGNATURE_START:MARSHALED_SIGNATURE_END], this.Signature[:MARSHALED_SIGNATURE_SIZE])
 
 	return result
 }
diff --git a/plugins/autopeering/types/salt/constants.go b/plugins/autopeering/types/salt/constants.go
index 5b75dd07131c32e4f1ee1bc51a4a0d8a3a498a04..399d6a728321eed83f5d0eb2e72d84eb745650cb 100644
--- a/plugins/autopeering/types/salt/constants.go
+++ b/plugins/autopeering/types/salt/constants.go
@@ -10,5 +10,5 @@ const (
 	SALT_BYTES_END = SALT_BYTES_START + SALT_BYTES_SIZE
 	SALT_TIME_END  = SALT_TIME_START + SALT_TIME_SIZE
 
-	SALT_MARSHALLED_SIZE = SALT_TIME_END
+	SALT_MARSHALED_SIZE = SALT_TIME_END
 )
diff --git a/plugins/autopeering/types/salt/salt.go b/plugins/autopeering/types/salt/salt.go
index 2da93db44ca1fbcc808d367da0967c658128df59..0da78e94d752a3f2e31e1e757034adff135b5a38 100644
--- a/plugins/autopeering/types/salt/salt.go
+++ b/plugins/autopeering/types/salt/salt.go
@@ -25,17 +25,17 @@ func New(lifetime time.Duration) *Salt {
 	return salt
 }
 
-func Unmarshal(marshalledSalt []byte) (*Salt, error) {
-	if len(marshalledSalt) < SALT_MARSHALLED_SIZE {
-		return nil, errors.New("marshalled salt bytes not long enough")
+func Unmarshal(marshaledSalt []byte) (*Salt, error) {
+	if len(marshaledSalt) < SALT_MARSHALED_SIZE {
+		return nil, errors.New("marshaled salt bytes not long enough")
 	}
 
 	salt := &Salt{
 		Bytes: make([]byte, SALT_BYTES_SIZE),
 	}
-	copy(salt.Bytes, marshalledSalt[SALT_BYTES_START:SALT_BYTES_END])
+	copy(salt.Bytes, marshaledSalt[SALT_BYTES_START:SALT_BYTES_END])
 
-	if err := salt.ExpirationTime.UnmarshalBinary(marshalledSalt[SALT_TIME_START:SALT_TIME_END]); err != nil {
+	if err := salt.ExpirationTime.UnmarshalBinary(marshaledSalt[SALT_TIME_START:SALT_TIME_END]); err != nil {
 		return nil, err
 	}
 
diff --git a/plugins/cli/plugin.go b/plugins/cli/plugin.go
index c77cc83556bba49c9025c56d41092980865e7d6e..2f73f2393320ac72375f53c686cc8550ee4ab447 100644
--- a/plugins/cli/plugin.go
+++ b/plugins/cli/plugin.go
@@ -40,6 +40,4 @@ func init() {
 
 func configure(ctx *node.Plugin) {}
 
-func run(plugin *node.Plugin) {}
-
 var PLUGIN = node.NewPlugin("CLI", configure)
diff --git a/plugins/gossip/neighbors.go b/plugins/gossip/neighbors.go
index f268cf4c6cae22cbd0dde4b61ddc4f4013758533..f61e08d86a6d0eac60eff86fe65df56acb75105c 100644
--- a/plugins/gossip/neighbors.go
+++ b/plugins/gossip/neighbors.go
@@ -194,7 +194,7 @@ func AddNeighbor(newNeighbor *Neighbor) {
 
 		Events.AddNeighbor.Trigger(newNeighbor)
 	} else {
-		if !newNeighbor.Equals(neighbor) {
+		if !neighbor.Equals(newNeighbor) {
 			neighbor.Identity = newNeighbor.Identity
 			neighbor.Port = newNeighbor.Port
 			neighbor.Address = newNeighbor.Address
diff --git a/plugins/gossip/protocol_v1.go b/plugins/gossip/protocol_v1.go
index 628492973a1c35c4914f1e470468f8cd1d062c5b..b0adc6addc6ce15fd4029e9acad0009fca7b805e 100644
--- a/plugins/gossip/protocol_v1.go
+++ b/plugins/gossip/protocol_v1.go
@@ -72,7 +72,7 @@ type indentificationStateV1 struct {
 func newIndentificationStateV1(protocol *protocol) *indentificationStateV1 {
 	return &indentificationStateV1{
 		protocol: protocol,
-		buffer:   make([]byte, MARSHALLED_IDENTITY_TOTAL_SIZE),
+		buffer:   make([]byte, MARSHALED_IDENTITY_TOTAL_SIZE),
 		offset:   0,
 	}
 }
@@ -81,7 +81,7 @@ func (state *indentificationStateV1) Receive(data []byte, offset int, length int
 	bytesRead := byteutils.ReadAvailableBytesToBuffer(state.buffer, state.offset, data, offset, length)
 
 	state.offset += bytesRead
-	if state.offset == MARSHALLED_IDENTITY_TOTAL_SIZE {
+	if state.offset == MARSHALED_IDENTITY_TOTAL_SIZE {
 		if receivedIdentity, err := unmarshalIdentity(state.buffer); err != nil {
 			return bytesRead, ErrInvalidAuthenticationMessage.Derive(err, "invalid authentication message")
 		} else {
@@ -125,9 +125,9 @@ func (state *indentificationStateV1) Send(param interface{}) errors.Identifiable
 }
 
 func unmarshalIdentity(data []byte) (*identity.Identity, error) {
-	identifier := data[MARSHALLED_IDENTITY_START:MARSHALLED_IDENTITY_END]
+	identifier := data[MARSHALED_IDENTITY_START:MARSHALED_IDENTITY_END]
 
-	if restoredIdentity, err := identity.FromSignedData(identifier, data[MARSHALLED_IDENTITY_SIGNATURE_START:MARSHALLED_IDENTITY_SIGNATURE_END]); err != nil {
+	if restoredIdentity, err := identity.FromSignedData(identifier, data[MARSHALED_IDENTITY_SIGNATURE_START:MARSHALED_IDENTITY_SIGNATURE_END]); err != nil {
 		return nil, err
 	} else {
 		if bytes.Equal(identifier, restoredIdentity.Identifier) {
@@ -383,16 +383,16 @@ const (
 	DISPATCH_TRANSACTION = byte(1)
 	DISPATCH_REQUEST     = byte(2)
 
-	MARSHALLED_IDENTITY_START           = 0
-	MARSHALLED_IDENTITY_SIGNATURE_START = MARSHALLED_IDENTITY_END
+	MARSHALED_IDENTITY_START           = 0
+	MARSHALED_IDENTITY_SIGNATURE_START = MARSHALED_IDENTITY_END
 
-	MARSHALLED_IDENTITY_SIZE           = 20
-	MARSHALLED_IDENTITY_SIGNATURE_SIZE = 65
+	MARSHALED_IDENTITY_SIZE           = 20
+	MARSHALED_IDENTITY_SIGNATURE_SIZE = 65
 
-	MARSHALLED_IDENTITY_END           = MARSHALLED_IDENTITY_START + MARSHALLED_IDENTITY_SIZE
-	MARSHALLED_IDENTITY_SIGNATURE_END = MARSHALLED_IDENTITY_SIGNATURE_START + MARSHALLED_IDENTITY_SIGNATURE_SIZE
+	MARSHALED_IDENTITY_END           = MARSHALED_IDENTITY_START + MARSHALED_IDENTITY_SIZE
+	MARSHALED_IDENTITY_SIGNATURE_END = MARSHALED_IDENTITY_SIGNATURE_START + MARSHALED_IDENTITY_SIGNATURE_SIZE
 
-	MARSHALLED_IDENTITY_TOTAL_SIZE = MARSHALLED_IDENTITY_SIGNATURE_END
+	MARSHALED_IDENTITY_TOTAL_SIZE = MARSHALED_IDENTITY_SIGNATURE_END
 )
 
 // endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/plugins/gossip/transaction_processor_test.go b/plugins/gossip/transaction_processor_test.go
index c07602df5f71f7b93168bdd8f01271a994a50697..86b6349a9f3b32d7b3c10d07331647929500d2bb 100644
--- a/plugins/gossip/transaction_processor_test.go
+++ b/plugins/gossip/transaction_processor_test.go
@@ -9,7 +9,11 @@ import (
 )
 
 func BenchmarkProcessSimilarTransactionsFiltered(b *testing.B) {
+<<<<<<< HEAD
+	byteArray := setupTransaction(transaction.MARSHALED_TOTAL_SIZE / ternary.NUMBER_OF_TRITS_IN_A_BYTE)
+=======
 	byteArray := setupTransaction(meta_transaction.MARSHALLED_TOTAL_SIZE / ternary.NUMBER_OF_TRITS_IN_A_BYTE)
+>>>>>>> master
 
 	b.ResetTimer()
 
@@ -19,7 +23,11 @@ func BenchmarkProcessSimilarTransactionsFiltered(b *testing.B) {
 }
 
 func BenchmarkProcessSimilarTransactionsUnfiltered(b *testing.B) {
+<<<<<<< HEAD
+	byteArray := setupTransaction(transaction.MARSHALED_TOTAL_SIZE / ternary.NUMBER_OF_TRITS_IN_A_BYTE)
+=======
 	byteArray := setupTransaction(meta_transaction.MARSHALLED_TOTAL_SIZE / ternary.NUMBER_OF_TRITS_IN_A_BYTE)
+>>>>>>> master
 
 	b.ResetTimer()
 
diff --git a/plugins/statusscreen/ui_header_bar.go b/plugins/statusscreen/ui_header_bar.go
index 5d7a3993586341c8d2dbb8c481621bab94029aaa..66ab397c5c45f1f24c868611f6f966cf023fe7de 100644
--- a/plugins/statusscreen/ui_header_bar.go
+++ b/plugins/statusscreen/ui_header_bar.go
@@ -62,7 +62,7 @@ func NewUIHeaderBar() *UIHeaderBar {
 }
 
 func (headerBar *UIHeaderBar) Update() {
-	duration := time.Now().Sub(start)
+	duration := time.Since(start)
 
 	headerBar.InfoContainer.Clear()
 
@@ -119,7 +119,6 @@ func (headerBar *UIHeaderBar) Update() {
 
 	if !padded {
 		fmt.Fprintf(headerBar.InfoContainer, "%37v", "")
-		padded = true
 	}
 	fmt.Fprintf(headerBar.InfoContainer, "%02ds  ", int(duration.Seconds())%60)
 }
diff --git a/plugins/tangle/approvers.go b/plugins/tangle/approvers.go
index f10291d47b8a4147c50625938fb46b6fc2ef8428..6b2f03d9b3a209a36064ace7eb914f608b17e0f2 100644
--- a/plugins/tangle/approvers.go
+++ b/plugins/tangle/approvers.go
@@ -94,18 +94,18 @@ func (approvers *Approvers) GetHash() (result ternary.Trinary) {
 }
 
 func (approvers *Approvers) Marshal() (result []byte) {
-	result = make([]byte, MARSHALLED_APPROVERS_MIN_SIZE+len(approvers.hashes)*MARSHALLED_APPROVERS_HASH_SIZE)
+	result = make([]byte, MARSHALED_APPROVERS_MIN_SIZE+len(approvers.hashes)*MARSHALED_APPROVERS_HASH_SIZE)
 
 	approvers.hashesMutex.RLock()
 
-	binary.BigEndian.PutUint64(result[MARSHALLED_APPROVERS_HASHES_COUNT_START:MARSHALLED_APPROVERS_HASHES_COUNT_END], uint64(len(approvers.hashes)))
+	binary.BigEndian.PutUint64(result[MARSHALED_APPROVERS_HASHES_COUNT_START:MARSHALED_APPROVERS_HASHES_COUNT_END], uint64(len(approvers.hashes)))
 
-	copy(result[MARSHALLED_APPROVERS_HASH_START:MARSHALLED_APPROVERS_HASH_END], approvers.hash.CastToBytes())
+	copy(result[MARSHALED_APPROVERS_HASH_START:MARSHALED_APPROVERS_HASH_END], approvers.hash.CastToBytes())
 
 	i := 0
 	for hash := range approvers.hashes {
-		var HASH_START = MARSHALLED_APPROVERS_HASHES_START + i*(MARSHALLED_APPROVERS_HASH_SIZE)
-		var HASH_END = HASH_START * MARSHALLED_APPROVERS_HASH_SIZE
+		var HASH_START = MARSHALED_APPROVERS_HASHES_START + i*(MARSHALED_APPROVERS_HASH_SIZE)
+		var HASH_END = HASH_START * MARSHALED_APPROVERS_HASH_SIZE
 
 		copy(result[HASH_START:HASH_END], hash.CastToBytes())
 
@@ -120,23 +120,23 @@ func (approvers *Approvers) Marshal() (result []byte) {
 func (approvers *Approvers) Unmarshal(data []byte) (err errors.IdentifiableError) {
 	dataLen := len(data)
 
-	if dataLen <= MARSHALLED_APPROVERS_MIN_SIZE {
-		return ErrMarshallFailed.Derive(errors.New("unmarshall failed"), "marshalled approvers are too short")
+	if dataLen <= MARSHALED_APPROVERS_MIN_SIZE {
+		return ErrMarshallFailed.Derive(errors.New("unmarshall failed"), "marshaled approvers are too short")
 	}
 
-	hashesCount := binary.BigEndian.Uint64(data[MARSHALLED_APPROVERS_HASHES_COUNT_START:MARSHALLED_APPROVERS_HASHES_COUNT_END])
+	hashesCount := binary.BigEndian.Uint64(data[MARSHALED_APPROVERS_HASHES_COUNT_START:MARSHALED_APPROVERS_HASHES_COUNT_END])
 
-	if dataLen <= MARSHALLED_APPROVERS_MIN_SIZE+int(hashesCount)*MARSHALLED_APPROVERS_HASH_SIZE {
-		return ErrMarshallFailed.Derive(errors.New("unmarshall failed"), "marshalled approvers are too short for "+strconv.FormatUint(hashesCount, 10)+" approvers")
+	if dataLen <= MARSHALED_APPROVERS_MIN_SIZE+int(hashesCount)*MARSHALED_APPROVERS_HASH_SIZE {
+		return ErrMarshallFailed.Derive(errors.New("unmarshall failed"), "marshaled approvers are too short for "+strconv.FormatUint(hashesCount, 10)+" approvers")
 	}
 
 	approvers.hashesMutex.Lock()
 
-	approvers.hash = ternary.Trinary(typeutils.BytesToString(data[MARSHALLED_APPROVERS_HASH_START:MARSHALLED_APPROVERS_HASH_END]))
+	approvers.hash = ternary.Trinary(typeutils.BytesToString(data[MARSHALED_APPROVERS_HASH_START:MARSHALED_APPROVERS_HASH_END]))
 	approvers.hashes = make(map[ternary.Trinary]bool, hashesCount)
 	for i := uint64(0); i < hashesCount; i++ {
-		var HASH_START = MARSHALLED_APPROVERS_HASHES_START + i*(MARSHALLED_APPROVERS_HASH_SIZE)
-		var HASH_END = HASH_START * MARSHALLED_APPROVERS_HASH_SIZE
+		var HASH_START = MARSHALED_APPROVERS_HASHES_START + i*(MARSHALED_APPROVERS_HASH_SIZE)
+		var HASH_END = HASH_START * MARSHALED_APPROVERS_HASH_SIZE
 
 		approvers.hashes[ternary.Trinary(typeutils.BytesToString(data[HASH_START:HASH_END]))] = true
 	}
@@ -149,16 +149,16 @@ func (approvers *Approvers) Unmarshal(data []byte) (err errors.IdentifiableError
 // endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 const (
-	MARSHALLED_APPROVERS_HASHES_COUNT_START = 0
-	MARSHALLED_APPROVERS_HASH_START         = MARSHALLED_APPROVERS_HASHES_COUNT_END
-	MARSHALLED_APPROVERS_HASHES_START       = MARSHALLED_APPROVERS_HASH_END
+	MARSHALED_APPROVERS_HASHES_COUNT_START = 0
+	MARSHALED_APPROVERS_HASH_START         = MARSHALED_APPROVERS_HASHES_COUNT_END
+	MARSHALED_APPROVERS_HASHES_START       = MARSHALED_APPROVERS_HASH_END
 
-	MARSHALLED_APPROVERS_HASHES_COUNT_END = MARSHALLED_APPROVERS_HASHES_COUNT_START + MARSHALLED_APPROVERS_HASHES_COUNT_SIZE
-	MARSHALLED_APPROVERS_HASH_END         = MARSHALLED_APPROVERS_HASH_START + MARSHALLED_APPROVERS_HASH_SIZE
+	MARSHALED_APPROVERS_HASHES_COUNT_END = MARSHALED_APPROVERS_HASHES_COUNT_START + MARSHALED_APPROVERS_HASHES_COUNT_SIZE
+	MARSHALED_APPROVERS_HASH_END         = MARSHALED_APPROVERS_HASH_START + MARSHALED_APPROVERS_HASH_SIZE
 
-	MARSHALLED_APPROVERS_HASHES_COUNT_SIZE = 8
-	MARSHALLED_APPROVERS_HASH_SIZE         = 81
-	MARSHALLED_APPROVERS_MIN_SIZE          = MARSHALLED_APPROVERS_HASHES_COUNT_SIZE + MARSHALLED_APPROVERS_HASH_SIZE
+	MARSHALED_APPROVERS_HASHES_COUNT_SIZE = 8
+	MARSHALED_APPROVERS_HASH_SIZE         = 81
+	MARSHALED_APPROVERS_MIN_SIZE          = MARSHALED_APPROVERS_HASHES_COUNT_SIZE + MARSHALED_APPROVERS_HASH_SIZE
 )
 
 // region private methods without locking //////////////////////////////////////////////////////////////////////////////
@@ -217,9 +217,10 @@ func getApproversFromDatabase(transactionHash ternary.Trinary) (result *Approver
 }
 
 func databaseContainsApprovers(transactionHash ternary.Trinary) (bool, errors.IdentifiableError) {
-	if result, err := approversDatabase.Contains(transactionHash.CastToBytes()); err != nil {
+	result, err := approversDatabase.Contains(transactionHash.CastToBytes())
+	if err != nil {
 		return false, ErrDatabaseError.Derive(err, "failed to check if the transaction exists")
-	} else {
-		return result, nil
 	}
+
+	return result, nil
 }
diff --git a/plugins/tangle/transaction_metadata.go b/plugins/tangle/transaction_metadata.go
index 4b0dc22dd61b0b7e12ba5a1e106094c51496f569..7798e0396857691537b9423f7fa2faad25053cad 100644
--- a/plugins/tangle/transaction_metadata.go
+++ b/plugins/tangle/transaction_metadata.go
@@ -42,122 +42,122 @@ func NewTransactionMetadata(hash ternary.Trinary) *TransactionMetadata {
 
 // region getters and setters //////////////////////////////////////////////////////////////////////////////////////////
 
-func (metaData *TransactionMetadata) GetHash() ternary.Trinary {
-	metaData.hashMutex.RLock()
-	defer metaData.hashMutex.RUnlock()
+func (metadata *TransactionMetadata) GetHash() ternary.Trinary {
+	metadata.hashMutex.RLock()
+	defer metadata.hashMutex.RUnlock()
 
-	return metaData.hash
+	return metadata.hash
 }
 
-func (metaData *TransactionMetadata) SetHash(hash ternary.Trinary) {
-	metaData.hashMutex.RLock()
-	if metaData.hash != hash {
-		metaData.hashMutex.RUnlock()
-		metaData.hashMutex.Lock()
-		defer metaData.hashMutex.Unlock()
-		if metaData.hash != hash {
-			metaData.hash = hash
+func (metadata *TransactionMetadata) SetHash(hash ternary.Trinary) {
+	metadata.hashMutex.RLock()
+	if metadata.hash != hash {
+		metadata.hashMutex.RUnlock()
+		metadata.hashMutex.Lock()
+		defer metadata.hashMutex.Unlock()
+		if metadata.hash != hash {
+			metadata.hash = hash
 
-			metaData.SetModified(true)
+			metadata.SetModified(true)
 		}
 	} else {
-		metaData.hashMutex.RUnlock()
+		metadata.hashMutex.RUnlock()
 	}
 }
 
-func (metaData *TransactionMetadata) GetReceivedTime() time.Time {
-	metaData.receivedTimeMutex.RLock()
-	defer metaData.receivedTimeMutex.RUnlock()
+func (metadata *TransactionMetadata) GetReceivedTime() time.Time {
+	metadata.receivedTimeMutex.RLock()
+	defer metadata.receivedTimeMutex.RUnlock()
 
-	return metaData.receivedTime
+	return metadata.receivedTime
 }
 
-func (metaData *TransactionMetadata) SetReceivedTime(receivedTime time.Time) {
-	metaData.receivedTimeMutex.RLock()
-	if metaData.receivedTime != receivedTime {
-		metaData.receivedTimeMutex.RUnlock()
-		metaData.receivedTimeMutex.Lock()
-		defer metaData.receivedTimeMutex.Unlock()
-		if metaData.receivedTime != receivedTime {
-			metaData.receivedTime = receivedTime
-
-			metaData.SetModified(true)
+func (metadata *TransactionMetadata) SetReceivedTime(receivedTime time.Time) {
+	metadata.receivedTimeMutex.RLock()
+	if metadata.receivedTime != receivedTime {
+		metadata.receivedTimeMutex.RUnlock()
+		metadata.receivedTimeMutex.Lock()
+		defer metadata.receivedTimeMutex.Unlock()
+		if metadata.receivedTime != receivedTime {
+			metadata.receivedTime = receivedTime
+
+			metadata.SetModified(true)
 		}
 	} else {
-		metaData.receivedTimeMutex.RUnlock()
+		metadata.receivedTimeMutex.RUnlock()
 	}
 }
 
-func (metaData *TransactionMetadata) GetSolid() bool {
-	metaData.solidMutex.RLock()
-	defer metaData.solidMutex.RUnlock()
+func (metadata *TransactionMetadata) GetSolid() bool {
+	metadata.solidMutex.RLock()
+	defer metadata.solidMutex.RUnlock()
 
-	return metaData.solid
+	return metadata.solid
 }
 
-func (metaData *TransactionMetadata) SetSolid(solid bool) bool {
-	metaData.solidMutex.RLock()
-	if metaData.solid != solid {
-		metaData.solidMutex.RUnlock()
-		metaData.solidMutex.Lock()
-		defer metaData.solidMutex.Unlock()
-		if metaData.solid != solid {
-			metaData.solid = solid
+func (metadata *TransactionMetadata) SetSolid(solid bool) bool {
+	metadata.solidMutex.RLock()
+	if metadata.solid != solid {
+		metadata.solidMutex.RUnlock()
+		metadata.solidMutex.Lock()
+		defer metadata.solidMutex.Unlock()
+		if metadata.solid != solid {
+			metadata.solid = solid
 
-			metaData.SetModified(true)
+			metadata.SetModified(true)
 
 			return true
 		}
 	} else {
-		metaData.solidMutex.RUnlock()
+		metadata.solidMutex.RUnlock()
 	}
 
 	return false
 }
 
-func (metaData *TransactionMetadata) GetLiked() bool {
-	metaData.likedMutex.RLock()
-	defer metaData.likedMutex.RUnlock()
+func (metadata *TransactionMetadata) GetLiked() bool {
+	metadata.likedMutex.RLock()
+	defer metadata.likedMutex.RUnlock()
 
-	return metaData.liked
+	return metadata.liked
 }
 
-func (metaData *TransactionMetadata) SetLiked(liked bool) {
-	metaData.likedMutex.RLock()
-	if metaData.liked != liked {
-		metaData.likedMutex.RUnlock()
-		metaData.likedMutex.Lock()
-		defer metaData.likedMutex.Unlock()
-		if metaData.liked != liked {
-			metaData.liked = liked
-
-			metaData.SetModified(true)
+func (metadata *TransactionMetadata) SetLiked(liked bool) {
+	metadata.likedMutex.RLock()
+	if metadata.liked != liked {
+		metadata.likedMutex.RUnlock()
+		metadata.likedMutex.Lock()
+		defer metadata.likedMutex.Unlock()
+		if metadata.liked != liked {
+			metadata.liked = liked
+
+			metadata.SetModified(true)
 		}
 	} else {
-		metaData.likedMutex.RUnlock()
+		metadata.likedMutex.RUnlock()
 	}
 }
 
-func (metaData *TransactionMetadata) GetFinalized() bool {
-	metaData.finalizedMutex.RLock()
-	defer metaData.finalizedMutex.RUnlock()
+func (metadata *TransactionMetadata) GetFinalized() bool {
+	metadata.finalizedMutex.RLock()
+	defer metadata.finalizedMutex.RUnlock()
 
-	return metaData.finalized
+	return metadata.finalized
 }
 
-func (metaData *TransactionMetadata) SetFinalized(finalized bool) {
-	metaData.finalizedMutex.RLock()
-	if metaData.finalized != finalized {
-		metaData.finalizedMutex.RUnlock()
-		metaData.finalizedMutex.Lock()
-		defer metaData.finalizedMutex.Unlock()
-		if metaData.finalized != finalized {
-			metaData.finalized = finalized
-
-			metaData.SetModified(true)
+func (metadata *TransactionMetadata) SetFinalized(finalized bool) {
+	metadata.finalizedMutex.RLock()
+	if metadata.finalized != finalized {
+		metadata.finalizedMutex.RUnlock()
+		metadata.finalizedMutex.Lock()
+		defer metadata.finalizedMutex.Unlock()
+		if metadata.finalized != finalized {
+			metadata.finalized = finalized
+
+			metadata.SetModified(true)
 		}
 	} else {
-		metaData.finalizedMutex.RUnlock()
+		metadata.finalizedMutex.RUnlock()
 	}
 }
 
@@ -179,10 +179,10 @@ func (metadata *TransactionMetadata) SetModified(modified bool) {
 
 // endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-// region marshalling functions ////////////////////////////////////////////////////////////////////////////////////////
+// region marshaling functions ////////////////////////////////////////////////////////////////////////////////////////
 
 func (metadata *TransactionMetadata) Marshal() ([]byte, errors.IdentifiableError) {
-	marshalledMetadata := make([]byte, MARSHALLED_TOTAL_SIZE)
+	marshaledMetadata := make([]byte, MARSHALED_TOTAL_SIZE)
 
 	metadata.receivedTimeMutex.RLock()
 	defer metadata.receivedTimeMutex.RUnlock()
@@ -193,13 +193,13 @@ func (metadata *TransactionMetadata) Marshal() ([]byte, errors.IdentifiableError
 	metadata.finalizedMutex.RLock()
 	defer metadata.finalizedMutex.RUnlock()
 
-	copy(marshalledMetadata[MARSHALLED_HASH_START:MARSHALLED_HASH_END], metadata.hash.CastToBytes())
+	copy(marshaledMetadata[MARSHALED_HASH_START:MARSHALED_HASH_END], metadata.hash.CastToBytes())
 
-	marshalledReceivedTime, err := metadata.receivedTime.MarshalBinary()
+	marshaledReceivedTime, err := metadata.receivedTime.MarshalBinary()
 	if err != nil {
 		return nil, ErrMarshallFailed.Derive(err, "failed to marshal received time")
 	}
-	copy(marshalledMetadata[MARSHALLED_RECEIVED_TIME_START:MARSHALLED_RECEIVED_TIME_END], marshalledReceivedTime)
+	copy(marshaledMetadata[MARSHALED_RECEIVED_TIME_START:MARSHALED_RECEIVED_TIME_END], marshaledReceivedTime)
 
 	var booleanFlags bitutils.BitMask
 	if metadata.solid {
@@ -211,9 +211,9 @@ func (metadata *TransactionMetadata) Marshal() ([]byte, errors.IdentifiableError
 	if metadata.finalized {
 		booleanFlags = booleanFlags.SetFlag(2)
 	}
-	marshalledMetadata[MARSHALLED_FLAGS_START] = byte(booleanFlags)
+	marshaledMetadata[MARSHALED_FLAGS_START] = byte(booleanFlags)
 
-	return marshalledMetadata, nil
+	return marshaledMetadata, nil
 }
 
 func (metadata *TransactionMetadata) Unmarshal(data []byte) errors.IdentifiableError {
@@ -228,13 +228,13 @@ func (metadata *TransactionMetadata) Unmarshal(data []byte) errors.IdentifiableE
 	metadata.finalizedMutex.Lock()
 	defer metadata.finalizedMutex.Unlock()
 
-	metadata.hash = ternary.Trinary(typeutils.BytesToString(data[MARSHALLED_HASH_START:MARSHALLED_HASH_END]))
+	metadata.hash = ternary.Trinary(typeutils.BytesToString(data[MARSHALED_HASH_START:MARSHALED_HASH_END]))
 
-	if err := metadata.receivedTime.UnmarshalBinary(data[MARSHALLED_RECEIVED_TIME_START:MARSHALLED_RECEIVED_TIME_END]); err != nil {
+	if err := metadata.receivedTime.UnmarshalBinary(data[MARSHALED_RECEIVED_TIME_START:MARSHALED_RECEIVED_TIME_END]); err != nil {
 		return ErrUnmarshalFailed.Derive(err, "could not unmarshal the received time")
 	}
 
-	booleanFlags := bitutils.BitMask(data[MARSHALLED_FLAGS_START])
+	booleanFlags := bitutils.BitMask(data[MARSHALED_FLAGS_START])
 	if booleanFlags.HasFlag(0) {
 		metadata.solid = true
 	}
@@ -257,19 +257,19 @@ func (metadata *TransactionMetadata) Unmarshal(data []byte) errors.IdentifiableE
 // region constants and variables //////////////////////////////////////////////////////////////////////////////////////
 
 const (
-	MARSHALLED_HASH_START          = 0
-	MARSHALLED_RECEIVED_TIME_START = MARSHALLED_HASH_END
-	MARSHALLED_FLAGS_START         = MARSHALLED_RECEIVED_TIME_END
+	MARSHALED_HASH_START          = 0
+	MARSHALED_RECEIVED_TIME_START = MARSHALED_HASH_END
+	MARSHALED_FLAGS_START         = MARSHALED_RECEIVED_TIME_END
 
-	MARSHALLED_HASH_END          = MARSHALLED_HASH_START + MARSHALLED_HASH_SIZE
-	MARSHALLED_RECEIVED_TIME_END = MARSHALLED_RECEIVED_TIME_START + MARSHALLED_RECEIVED_TIME_SIZE
-	MARSHALLED_FLAGS_END         = MARSHALLED_FLAGS_START + MARSHALLED_FLAGS_SIZE
+	MARSHALED_HASH_END          = MARSHALED_HASH_START + MARSHALED_HASH_SIZE
+	MARSHALED_RECEIVED_TIME_END = MARSHALED_RECEIVED_TIME_START + MARSHALED_RECEIVED_TIME_SIZE
+	MARSHALED_FLAGS_END         = MARSHALED_FLAGS_START + MARSHALED_FLAGS_SIZE
 
-	MARSHALLED_HASH_SIZE          = 81
-	MARSHALLED_RECEIVED_TIME_SIZE = 15
-	MARSHALLED_FLAGS_SIZE         = 1
+	MARSHALED_HASH_SIZE          = 81
+	MARSHALED_RECEIVED_TIME_SIZE = 15
+	MARSHALED_FLAGS_SIZE         = 1
 
-	MARSHALLED_TOTAL_SIZE = MARSHALLED_FLAGS_END
+	MARSHALED_TOTAL_SIZE = MARSHALED_FLAGS_END
 )
 
 // endregion ////////////////////////////////////////////////////////////////////////////////////////////////////////////