From b9404478e329ea5389b0c57c4b419f3b16f6742d Mon Sep 17 00:00:00 2001
From: Hans Moog <hm@mkjc.net>
Date: Sat, 28 Mar 2020 01:04:45 +0100
Subject: [PATCH] Feat: started reworking output model (#311)

* Feat: started reworking output model

* Refactor: refactored some of the model

* Refactor: started to refactor some additional models

* Refactor: started to refactor message layer

* Refactor: still refactoring :/

* Refactor: refactored some more

* Refactor: some error messages are gone YAY

* Refactor: refactor complete
---
 go.mod                                        |   2 +-
 go.sum                                        |   8 +
 .../model => messagelayer}/message/id.go      |   0
 .../message/message.go}                       | 190 ++++++++++++------
 .../data => messagelayer/payload}/data.go     |  46 ++---
 .../message => messagelayer}/payload/id.go    |   0
 .../payload/payload.go                        |   6 +
 .../message => messagelayer}/payload/type.go  |   0
 .../payload/type_register.go                  |   0
 .../binary/messagelayer/tangle/approver.go    | 164 +++++++++++++++
 .../{ => messagelayer}/tangle/events.go       |   9 +-
 .../messagelayer/tangle/messagemetadata.go    | 171 ++++++++++++++++
 .../messagelayer/tangle/missingmessage.go     |  82 ++++++++
 .../{ => messagelayer}/tangle/tangle.go       | 143 +++++++------
 .../{ => messagelayer}/tangle/tangle_test.go  |  39 ++--
 .../test/transaction_test.go                  |  10 +-
 .../tipselector/events.go                     |   3 +-
 .../tipselector/tipselector.go                |   7 +-
 .../tipselector/tipselector_test.go           |  10 +-
 .../recently_seen_bytes_filter.go             |   0
 .../transaction_signature_filter.go           |  16 +-
 .../transactionparser/bytes_filter.go         |   0
 .../transactionparser/events.go               |   0
 .../transactionparser/transaction_filter.go   |  14 ++
 .../transactionparser/transactionparser.go    |  15 +-
 .../transactionparser_test.go                 |  12 +-
 .../transactionrequester/constants.go         |   0
 .../transactionrequester/events.go            |   0
 .../transactionrequester/options.go           |   0
 .../transactionrequester.go                   |   2 +-
 packages/binary/spammer/spammer.go            |  12 +-
 .../binary/storageprefix/storageprefix.go     |   8 +-
 .../binary/tangle/model/approver/approver.go  |  59 ------
 .../tangle/model/approver/cached_approver.go  |  33 ---
 .../model/message/cached_transaction.go       |  31 ---
 packages/binary/tangle/model/message/init.go  |  10 -
 .../tangle/model/message/payload/data/init.go |   9 -
 .../cached_missingtransaction.go              |  21 --
 .../missingtransaction/missingtransaction.go  |  58 ------
 .../cached_transactionmetadata.go             |  25 ---
 .../tangle/model/transactionmetadata/proto.go |  51 -----
 .../transactionmetadata.go                    | 109 ----------
 .../transactionparser/transaction_filter.go   |  14 --
 .../binary/valuetransfer/payload/payload.go   | 124 ++++++------
 .../valuetransfer/payload/payload_test.go     |   2 +-
 .../binary/valuetransfer/tangle/attachment.go |   8 +-
 .../binary/valuetransfer/tangle/consumer.go   |   2 +-
 .../valuetransfer/tangle/missingoutput.go     |   8 +-
 .../valuetransfer/tangle/missingpayload.go    |   8 +-
 .../valuetransfer/tangle/payloadapprover.go   |  16 +-
 .../valuetransfer/tangle/payloadmetadata.go   |  19 +-
 .../binary/valuetransfer/tangle/tangle.go     |   2 +-
 .../tangle/transactionmetadata.go             |   4 +-
 .../tangle/transactionoutputmetadata.go       |   4 +-
 .../valuetransfer/transaction/output.go       |  10 +-
 .../valuetransfer/transaction/transaction.go  | 116 ++++++-----
 packages/gossip/manager.go                    |   6 +-
 packages/gossip/manager_test.go               |   7 +-
 pluginmgr/core/plugins.go                     |   4 +-
 plugins/gossip/gossip.go                      |  14 +-
 plugins/gossip/plugin.go                      |  14 +-
 plugins/graph/plugin.go                       |   6 +-
 plugins/{tangle => messagelayer}/plugin.go    |  31 ++-
 plugins/metrics/plugin.go                     |   8 +-
 plugins/spa/explorer_routes.go                |  10 +-
 plugins/spa/livefeed.go                       |  14 +-
 plugins/webapi/gtta/plugin.go                 |   9 +-
 plugins/webapi/spammer/plugin.go              |   4 +-
 68 files changed, 985 insertions(+), 854 deletions(-)
 rename packages/binary/{tangle/model => messagelayer}/message/id.go (100%)
 rename packages/binary/{tangle/model/message/transaction.go => messagelayer/message/message.go} (55%)
 rename packages/binary/{tangle/model/message/payload/data => messagelayer/payload}/data.go (64%)
 rename packages/binary/{tangle/model/message => messagelayer}/payload/id.go (100%)
 rename packages/binary/{tangle/model/message => messagelayer}/payload/payload.go (89%)
 rename packages/binary/{tangle/model/message => messagelayer}/payload/type.go (100%)
 rename packages/binary/{tangle/model/message => messagelayer}/payload/type_register.go (100%)
 create mode 100644 packages/binary/messagelayer/tangle/approver.go
 rename packages/binary/{ => messagelayer}/tangle/events.go (74%)
 create mode 100644 packages/binary/messagelayer/tangle/messagemetadata.go
 create mode 100644 packages/binary/messagelayer/tangle/missingmessage.go
 rename packages/binary/{ => messagelayer}/tangle/tangle.go (55%)
 rename packages/binary/{ => messagelayer}/tangle/tangle_test.go (52%)
 rename packages/binary/{tangle/model/message => messagelayer}/test/transaction_test.go (78%)
 rename packages/binary/{tangle => messagelayer}/tipselector/events.go (81%)
 rename packages/binary/{tangle => messagelayer}/tipselector/tipselector.go (92%)
 rename packages/binary/{tangle => messagelayer}/tipselector/tipselector_test.go (80%)
 rename packages/binary/{tangle => messagelayer}/transactionparser/builtinfilters/recently_seen_bytes_filter.go (100%)
 rename packages/binary/{tangle => messagelayer}/transactionparser/builtinfilters/transaction_signature_filter.go (74%)
 rename packages/binary/{tangle => messagelayer}/transactionparser/bytes_filter.go (100%)
 rename packages/binary/{tangle => messagelayer}/transactionparser/events.go (100%)
 create mode 100644 packages/binary/messagelayer/transactionparser/transaction_filter.go
 rename packages/binary/{tangle => messagelayer}/transactionparser/transactionparser.go (90%)
 rename packages/binary/{tangle => messagelayer}/transactionparser/transactionparser_test.go (72%)
 rename packages/binary/{tangle => messagelayer}/transactionrequester/constants.go (100%)
 rename packages/binary/{tangle => messagelayer}/transactionrequester/events.go (100%)
 rename packages/binary/{tangle => messagelayer}/transactionrequester/options.go (100%)
 rename packages/binary/{tangle => messagelayer}/transactionrequester/transactionrequester.go (96%)
 delete mode 100644 packages/binary/tangle/model/approver/approver.go
 delete mode 100644 packages/binary/tangle/model/approver/cached_approver.go
 delete mode 100644 packages/binary/tangle/model/message/cached_transaction.go
 delete mode 100644 packages/binary/tangle/model/message/init.go
 delete mode 100644 packages/binary/tangle/model/message/payload/data/init.go
 delete mode 100644 packages/binary/tangle/model/missingtransaction/cached_missingtransaction.go
 delete mode 100644 packages/binary/tangle/model/missingtransaction/missingtransaction.go
 delete mode 100644 packages/binary/tangle/model/transactionmetadata/cached_transactionmetadata.go
 delete mode 100644 packages/binary/tangle/model/transactionmetadata/proto.go
 delete mode 100644 packages/binary/tangle/model/transactionmetadata/transactionmetadata.go
 delete mode 100644 packages/binary/tangle/transactionparser/transaction_filter.go
 rename plugins/{tangle => messagelayer}/plugin.go (54%)

diff --git a/go.mod b/go.mod
index 0d6f4612..ff040d9c 100644
--- a/go.mod
+++ b/go.mod
@@ -10,7 +10,7 @@ require (
 	github.com/googollee/go-engine.io v1.4.3-0.20190924125625-798118fc0dd2
 	github.com/googollee/go-socket.io v1.4.3-0.20191204093753-683f8725b6d0
 	github.com/gorilla/websocket v1.4.1
-	github.com/iotaledger/hive.go v0.0.0-20200325224052-ac4d38108211
+	github.com/iotaledger/hive.go v0.0.0-20200326163241-4aa5b4d3b5b0
 	github.com/iotaledger/iota.go v1.0.0-beta.14
 	github.com/labstack/echo v3.3.10+incompatible
 	github.com/labstack/gommon v0.3.0 // indirect
diff --git a/go.sum b/go.sum
index 16b57bbd..3e63ee75 100644
--- a/go.sum
+++ b/go.sum
@@ -134,6 +134,14 @@ github.com/iotaledger/hive.go v0.0.0-20200325224052-ac4d38108211 h1:ckZnjlKHCqgs
 github.com/iotaledger/hive.go v0.0.0-20200325224052-ac4d38108211/go.mod h1:EfH+ZcYGFJzzoFpO7NHGi2k7+Xc84ASyp1EwjhI3eJc=
 github.com/iotaledger/hive.go v0.0.0-20200326125723-9ba81bd19b75 h1:oZdDKfciKDJm/txN1/Ax61CCuFyOc7Y7mpMCrrgCVwo=
 github.com/iotaledger/hive.go v0.0.0-20200326125723-9ba81bd19b75/go.mod h1:EfH+ZcYGFJzzoFpO7NHGi2k7+Xc84ASyp1EwjhI3eJc=
+github.com/iotaledger/hive.go v0.0.0-20200326133753-889dd6edb2ee h1:/PPAbuLfHtBQhV7n9sFh+wVKTvPH7pX6pCCFixq8LXw=
+github.com/iotaledger/hive.go v0.0.0-20200326133753-889dd6edb2ee/go.mod h1:EfH+ZcYGFJzzoFpO7NHGi2k7+Xc84ASyp1EwjhI3eJc=
+github.com/iotaledger/hive.go v0.0.0-20200326142220-1a50b54482ba h1:h6ilKICR660XPJDKazAcr9BDsKE4D0RveH59McjhIL0=
+github.com/iotaledger/hive.go v0.0.0-20200326142220-1a50b54482ba/go.mod h1:EfH+ZcYGFJzzoFpO7NHGi2k7+Xc84ASyp1EwjhI3eJc=
+github.com/iotaledger/hive.go v0.0.0-20200326161423-f9e74839ddef h1:TbOHnWsk2sKDc4z92mMXMZL2FCFpexOjLTxrnyi8Nc0=
+github.com/iotaledger/hive.go v0.0.0-20200326161423-f9e74839ddef/go.mod h1:4sloxRutRhCuXgAgtOu1ZxVM95Na+ovK9MRDEQGZlzw=
+github.com/iotaledger/hive.go v0.0.0-20200326163241-4aa5b4d3b5b0 h1:ADYgndjbLPrCxxoCfHItxb6RjB3dzFxHlQ+mrqk16g8=
+github.com/iotaledger/hive.go v0.0.0-20200326163241-4aa5b4d3b5b0/go.mod h1:4sloxRutRhCuXgAgtOu1ZxVM95Na+ovK9MRDEQGZlzw=
 github.com/iotaledger/iota.go v1.0.0-beta.9/go.mod h1:F6WBmYd98mVjAmmPVYhnxg8NNIWCjjH8VWT9qvv3Rc8=
 github.com/iotaledger/iota.go v1.0.0-beta.14 h1:Oeb28MfBuJEeXcGrLhTCJFtbsnc8y1u7xidsAmiOD5A=
 github.com/iotaledger/iota.go v1.0.0-beta.14/go.mod h1:F6WBmYd98mVjAmmPVYhnxg8NNIWCjjH8VWT9qvv3Rc8=
diff --git a/packages/binary/tangle/model/message/id.go b/packages/binary/messagelayer/message/id.go
similarity index 100%
rename from packages/binary/tangle/model/message/id.go
rename to packages/binary/messagelayer/message/id.go
diff --git a/packages/binary/tangle/model/message/transaction.go b/packages/binary/messagelayer/message/message.go
similarity index 55%
rename from packages/binary/tangle/model/message/transaction.go
rename to packages/binary/messagelayer/message/message.go
index 5b9f6785..7bd44f50 100644
--- a/packages/binary/tangle/model/message/transaction.go
+++ b/packages/binary/messagelayer/message/message.go
@@ -5,19 +5,20 @@ import (
 	"time"
 
 	"github.com/iotaledger/hive.go/marshalutil"
+	"github.com/iotaledger/hive.go/objectstorage"
 	"github.com/iotaledger/hive.go/stringify"
 
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/payload"
 	"github.com/iotaledger/goshimmer/packages/binary/signature/ed25119"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message/payload"
-
-	"github.com/iotaledger/hive.go/objectstorage"
 
 	"github.com/mr-tron/base58"
 
 	"golang.org/x/crypto/blake2b"
 )
 
-type Transaction struct {
+// region Message //////////////////////////////////////////////////////////////////////////////////////////////////////
+
+type Message struct {
 	// base functionality of StorableObject
 	objectstorage.StorableObjectFlags
 
@@ -44,8 +45,8 @@ type Transaction struct {
 }
 
 // New creates a new transaction with the details provided by the issuer.
-func New(trunkTransactionId Id, branchTransactionId Id, issuerKeyPair ed25119.KeyPair, issuingTime time.Time, sequenceNumber uint64, payload payload.Payload) (result *Transaction) {
-	return &Transaction{
+func New(trunkTransactionId Id, branchTransactionId Id, issuerKeyPair ed25119.KeyPair, issuingTime time.Time, sequenceNumber uint64, payload payload.Payload) (result *Message) {
+	return &Message{
 		trunkTransactionId:  trunkTransactionId,
 		branchTransactionId: branchTransactionId,
 		issuerPublicKey:     issuerKeyPair.PublicKey,
@@ -57,67 +58,69 @@ func New(trunkTransactionId Id, branchTransactionId Id, issuerKeyPair ed25119.Ke
 	}
 }
 
-// Get's called when we restore a transaction from storage. The bytes and the content will be unmarshaled by an external
-// caller (the objectStorage factory).
-func StorableObjectFromKey(id []byte) (result objectstorage.StorableObject, err error) {
-	var transactionId Id
-	copy(transactionId[:], id)
-
-	result = &Transaction{
-		id: &transactionId,
-	}
+func FromBytes(bytes []byte, optionalTargetObject ...*Message) (result *Message, err error, consumedBytes int) {
+	marshalUtil := marshalutil.New(bytes)
+	result, err = Parse(marshalUtil, optionalTargetObject...)
+	consumedBytes = marshalUtil.ReadOffset()
 
 	return
 }
 
-func FromBytes(bytes []byte, optionalTargetObject ...*Transaction) (result *Transaction, err error, consumedBytes int) {
+func Parse(marshalUtil *marshalutil.MarshalUtil, optionalTargetObject ...*Message) (result *Message, err error) {
 	// determine the target object that will hold the unmarshaled information
 	switch len(optionalTargetObject) {
 	case 0:
-		result = &Transaction{}
+		result = &Message{}
 	case 1:
 		result = optionalTargetObject[0]
 	default:
-		panic("too many arguments in call to FromBytes")
+		panic("too many arguments in call to Parse")
 	}
 
-	// initialize helper
-	marshalUtil := marshalutil.New(bytes)
+	if parsedObject, parseErr := marshalUtil.Parse(func(data []byte) (interface{}, error, int) {
+		return StorableObjectFromKey(data)
+	}); parseErr != nil {
+		err = parseErr
 
-	// parse information
-	if result.trunkTransactionId, err = ParseId(marshalUtil); err != nil {
-		return
-	}
-	if result.branchTransactionId, err = ParseId(marshalUtil); err != nil {
-		return
-	}
-	if result.issuerPublicKey, err = ed25119.ParsePublicKey(marshalUtil); err != nil {
 		return
+	} else {
+		result = parsedObject.(*Message)
 	}
-	if result.issuingTime, err = marshalUtil.ReadTime(); err != nil {
+	if _, err = marshalUtil.Parse(func(data []byte) (parseResult interface{}, parseErr error, parsedBytes int) {
+		parseErr, parsedBytes = result.UnmarshalObjectStorageValue(data)
+
 		return
-	}
-	if result.sequenceNumber, err = marshalUtil.ReadUint64(); err != nil {
+	}); err != nil {
 		return
 	}
-	if result.payload, err = payload.Parse(marshalUtil); err != nil {
-		return
+
+	return
+}
+
+// Get's called when we restore a transaction from storage. The bytes and the content will be unmarshaled by an external
+// caller (the objectStorage factory).
+func StorableObjectFromKey(key []byte, optionalTargetObject ...*Message) (result objectstorage.StorableObject, err error, consumedBytes int) {
+	// determine the target object that will hold the unmarshaled information
+	switch len(optionalTargetObject) {
+	case 0:
+		result = &Message{}
+	case 1:
+		result = optionalTargetObject[0]
+	default:
+		panic("too many arguments in call to StorableObjectFromKey")
 	}
-	if result.signature, err = ed25119.ParseSignature(marshalUtil); err != nil {
+
+	marshalUtil := marshalutil.New(key)
+	*result.(*Message).id, err = ParseId(marshalUtil)
+	if err != nil {
 		return
 	}
-
-	// return the number of bytes we processed
 	consumedBytes = marshalUtil.ReadOffset()
 
-	// store marshaled version
-	result.bytes = make([]byte, consumedBytes)
-	copy(result.bytes, bytes)
-
 	return
 }
 
-func (transaction *Transaction) VerifySignature() (result bool) {
+func (transaction *Message) VerifySignature() (result bool) {
 	transactionBytes := transaction.Bytes()
 
 	transaction.signatureMutex.RLock()
@@ -127,7 +130,7 @@ func (transaction *Transaction) VerifySignature() (result bool) {
 	return
 }
 
-func (transaction *Transaction) GetId() (result Id) {
+func (transaction *Message) GetId() (result Id) {
 	transaction.idMutex.RLock()
 	if transaction.id == nil {
 		transaction.idMutex.RUnlock()
@@ -150,29 +153,29 @@ func (transaction *Transaction) GetId() (result Id) {
 	return
 }
 
-func (transaction *Transaction) GetTrunkTransactionId() Id {
+func (transaction *Message) GetTrunkTransactionId() Id {
 	return transaction.trunkTransactionId
 }
 
-func (transaction *Transaction) GetBranchTransactionId() Id {
+func (transaction *Message) GetBranchTransactionId() Id {
 	return transaction.branchTransactionId
 }
 
 // IssuingTime returns the time when the transaction was created.
-func (transaction *Transaction) IssuingTime() time.Time {
+func (transaction *Message) IssuingTime() time.Time {
 	return transaction.issuingTime
 }
 
 // SequenceNumber returns the sequence number of this transaction.
-func (transaction *Transaction) SequenceNumber() uint64 {
+func (transaction *Message) SequenceNumber() uint64 {
 	return transaction.sequenceNumber
 }
 
-func (transaction *Transaction) GetPayload() payload.Payload {
+func (transaction *Message) GetPayload() payload.Payload {
 	return transaction.payload
 }
 
-func (transaction *Transaction) GetPayloadId() (result payload.Id) {
+func (transaction *Message) GetPayloadId() (result payload.Id) {
 	transaction.payloadIdMutex.RLock()
 	if transaction.payloadId == nil {
 		transaction.payloadIdMutex.RUnlock()
@@ -195,7 +198,7 @@ func (transaction *Transaction) GetPayloadId() (result payload.Id) {
 	return
 }
 
-func (transaction *Transaction) calculateTransactionId() Id {
+func (transaction *Message) calculateTransactionId() Id {
 	payloadId := transaction.GetPayloadId()
 
 	hashBase := make([]byte, IdLength+IdLength+payload.IdLength)
@@ -213,13 +216,13 @@ func (transaction *Transaction) calculateTransactionId() Id {
 	return blake2b.Sum512(hashBase)
 }
 
-func (transaction *Transaction) calculatePayloadId() payload.Id {
+func (transaction *Message) calculatePayloadId() payload.Id {
 	bytes := transaction.Bytes()
 
 	return blake2b.Sum512(bytes[2*IdLength:])
 }
 
-func (transaction *Transaction) Bytes() []byte {
+func (transaction *Message) Bytes() []byte {
 	transaction.bytesMutex.RLock()
 	if transaction.bytes != nil {
 		defer transaction.bytesMutex.RUnlock()
@@ -248,34 +251,95 @@ func (transaction *Transaction) Bytes() []byte {
 	return marshalUtil.Bytes()
 }
 
-// Since transactions are immutable and do not get changed after being created, we cache the result of the marshaling.
-func (transaction *Transaction) ObjectStorageValue() []byte {
-	return transaction.Bytes()
-}
+func (transaction *Message) UnmarshalObjectStorageValue(data []byte) (err error, consumedBytes int) {
+	// initialize helper
+	marshalUtil := marshalutil.New(data)
+
+	// parse information
+	if transaction.trunkTransactionId, err = ParseId(marshalUtil); err != nil {
+		return
+	}
+	if transaction.branchTransactionId, err = ParseId(marshalUtil); err != nil {
+		return
+	}
+	if transaction.issuerPublicKey, err = ed25119.ParsePublicKey(marshalUtil); err != nil {
+		return
+	}
+	if transaction.issuingTime, err = marshalUtil.ReadTime(); err != nil {
+		return
+	}
+	if transaction.sequenceNumber, err = marshalUtil.ReadUint64(); err != nil {
+		return
+	}
+	if transaction.payload, err = payload.Parse(marshalUtil); err != nil {
+		return
+	}
+	if transaction.signature, err = ed25119.ParseSignature(marshalUtil); err != nil {
+		return
+	}
+
+	// return the number of bytes we processed
+	consumedBytes = marshalUtil.ReadOffset()
 
-func (transaction *Transaction) UnmarshalObjectStorageValue(data []byte) (err error) {
-	_, err, _ = FromBytes(data, transaction)
+	// store marshaled version
+	transaction.bytes = make([]byte, consumedBytes)
+	copy(transaction.bytes, data)
 
 	return
 }
 
-func (transaction *Transaction) ObjectStorageKey() []byte {
-	transactionId := transaction.GetId()
+func (transaction *Message) ObjectStorageKey() []byte {
+	return transaction.GetId().Bytes()
+}
 
-	return transactionId[:]
+// Since transactions are immutable and do not get changed after being created, we cache the result of the marshaling.
+func (transaction *Message) ObjectStorageValue() []byte {
+	return transaction.Bytes()
 }
 
-func (transaction *Transaction) Update(other objectstorage.StorableObject) {
+func (transaction *Message) Update(other objectstorage.StorableObject) {
 	panic("transactions should never be overwritten and only stored once to optimize IO")
 }
 
-func (transaction *Transaction) String() string {
+func (transaction *Message) String() string {
 	transactionId := transaction.GetId()
 
-	return stringify.Struct("Transaction",
+	return stringify.Struct("Message",
 		stringify.StructField("id", base58.Encode(transactionId[:])),
 		stringify.StructField("trunkTransactionId", base58.Encode(transaction.trunkTransactionId[:])),
 		stringify.StructField("trunkTransactionId", base58.Encode(transaction.branchTransactionId[:])),
 		stringify.StructField("payload", transaction.payload),
 	)
 }
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region CachedMessage ////////////////////////////////////////////////////////////////////////////////////////////////
+
+type CachedMessage struct {
+	objectstorage.CachedObject
+}
+
+func (cachedMessage *CachedMessage) Retain() *CachedMessage {
+	return &CachedMessage{cachedMessage.CachedObject.Retain()}
+}
+
+func (cachedMessage *CachedMessage) Consume(consumer func(transaction *Message)) bool {
+	return cachedMessage.CachedObject.Consume(func(object objectstorage.StorableObject) {
+		consumer(object.(*Message))
+	})
+}
+
+func (cachedMessage *CachedMessage) Unwrap() *Message {
+	if untypedTransaction := cachedMessage.Get(); untypedTransaction == nil {
+		return nil
+	} else {
+		if typeCastedTransaction := untypedTransaction.(*Message); typeCastedTransaction == nil || typeCastedTransaction.IsDeleted() {
+			return nil
+		} else {
+			return typeCastedTransaction
+		}
+	}
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/packages/binary/tangle/model/message/payload/data/data.go b/packages/binary/messagelayer/payload/data.go
similarity index 64%
rename from packages/binary/tangle/model/message/payload/data/data.go
rename to packages/binary/messagelayer/payload/data.go
index 2be4b5db..1325ed35 100644
--- a/packages/binary/tangle/model/message/payload/data/data.go
+++ b/packages/binary/messagelayer/payload/data.go
@@ -1,27 +1,33 @@
-package data
+package payload
 
 import (
 	"github.com/iotaledger/hive.go/marshalutil"
 	"github.com/iotaledger/hive.go/stringify"
-
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message/payload"
 )
 
+var DataType = Type(0)
+
 type Data struct {
-	payloadType payload.Type
+	payloadType Type
 	data        []byte
 }
 
-var Type = payload.Type(0)
-
-func New(data []byte) *Data {
+func NewData(data []byte) *Data {
 	return &Data{
-		payloadType: Type,
+		payloadType: DataType,
 		data:        data,
 	}
 }
 
-func FromBytes(bytes []byte, optionalTargetObject ...*Data) (result *Data, err error, consumedBytes int) {
+func DataFromBytes(bytes []byte, optionalTargetObject ...*Data) (result *Data, err error, consumedBytes int) {
+	marshalUtil := marshalutil.New(bytes)
+	result, err = ParseData(marshalUtil, optionalTargetObject...)
+	consumedBytes = marshalUtil.ReadOffset()
+
+	return
+}
+
+func ParseData(marshalUtil *marshalutil.MarshalUtil, optionalTargetObject ...*Data) (result *Data, err error) {
 	// determine the target object that will hold the unmarshaled information
 	switch len(optionalTargetObject) {
 	case 0:
@@ -29,13 +35,10 @@ func FromBytes(bytes []byte, optionalTargetObject ...*Data) (result *Data, err e
 	case 1:
 		result = optionalTargetObject[0]
 	default:
-		panic("too many arguments in call to FromBytes")
+		panic("too many arguments in call to ParseData")
 	}
 
-	// initialize helper
-	marshalUtil := marshalutil.New(bytes)
-
-	// read data
+	// parse information
 	result.payloadType, err = marshalUtil.ReadUint32()
 	if err != nil {
 		return
@@ -49,17 +52,14 @@ func FromBytes(bytes []byte, optionalTargetObject ...*Data) (result *Data, err e
 		return
 	}
 
-	// return the number of bytes we processed
-	consumedBytes = marshalUtil.ReadOffset()
-
 	return
 }
 
-func (dataPayload *Data) Type() payload.Type {
+func (dataPayload *Data) Type() Type {
 	return dataPayload.payloadType
 }
 
-func (dataPayload *Data) GetData() []byte {
+func (dataPayload *Data) Data() []byte {
 	return dataPayload.data
 }
 
@@ -78,19 +78,19 @@ func (dataPayload *Data) Bytes() []byte {
 }
 
 func (dataPayload *Data) Unmarshal(data []byte) (err error) {
-	_, err, _ = FromBytes(data, dataPayload)
+	_, err, _ = DataFromBytes(data, dataPayload)
 
 	return
 }
 
 func (dataPayload *Data) String() string {
 	return stringify.Struct("Data",
-		stringify.StructField("data", string(dataPayload.GetData())),
+		stringify.StructField("data", string(dataPayload.Data())),
 	)
 }
 
-func GenericPayloadUnmarshalerFactory(payloadType payload.Type) payload.Unmarshaler {
-	return func(data []byte) (payload payload.Payload, err error) {
+func GenericPayloadUnmarshalerFactory(payloadType Type) Unmarshaler {
+	return func(data []byte) (payload Payload, err error) {
 		payload = &Data{
 			payloadType: payloadType,
 		}
diff --git a/packages/binary/tangle/model/message/payload/id.go b/packages/binary/messagelayer/payload/id.go
similarity index 100%
rename from packages/binary/tangle/model/message/payload/id.go
rename to packages/binary/messagelayer/payload/id.go
diff --git a/packages/binary/tangle/model/message/payload/payload.go b/packages/binary/messagelayer/payload/payload.go
similarity index 89%
rename from packages/binary/tangle/model/message/payload/payload.go
rename to packages/binary/messagelayer/payload/payload.go
index 55107384..97faf171 100644
--- a/packages/binary/tangle/model/message/payload/payload.go
+++ b/packages/binary/messagelayer/payload/payload.go
@@ -4,6 +4,12 @@ import (
 	"github.com/iotaledger/hive.go/marshalutil"
 )
 
+func init() {
+	SetGenericUnmarshalerFactory(GenericPayloadUnmarshalerFactory)
+
+	RegisterType(DataType, GenericPayloadUnmarshalerFactory(DataType))
+}
+
 type Payload interface {
 	Type() Type
 	Bytes() []byte
diff --git a/packages/binary/tangle/model/message/payload/type.go b/packages/binary/messagelayer/payload/type.go
similarity index 100%
rename from packages/binary/tangle/model/message/payload/type.go
rename to packages/binary/messagelayer/payload/type.go
diff --git a/packages/binary/tangle/model/message/payload/type_register.go b/packages/binary/messagelayer/payload/type_register.go
similarity index 100%
rename from packages/binary/tangle/model/message/payload/type_register.go
rename to packages/binary/messagelayer/payload/type_register.go
diff --git a/packages/binary/messagelayer/tangle/approver.go b/packages/binary/messagelayer/tangle/approver.go
new file mode 100644
index 00000000..9c638ed1
--- /dev/null
+++ b/packages/binary/messagelayer/tangle/approver.go
@@ -0,0 +1,164 @@
+package tangle
+
+import (
+	"github.com/iotaledger/hive.go/marshalutil"
+	"github.com/iotaledger/hive.go/objectstorage"
+	"github.com/iotaledger/hive.go/stringify"
+
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+)
+
+// region Approver /////////////////////////////////////////////////////////////////////////////////////////////////////
+
+type Approver struct {
+	objectstorage.StorableObjectFlags
+
+	referencedMessageId message.Id
+	approvingMessageId  message.Id
+}
+
+func NewApprover(referencedTransaction message.Id, approvingTransaction message.Id) *Approver {
+	approver := &Approver{
+		referencedMessageId: referencedTransaction,
+		approvingMessageId:  approvingTransaction,
+	}
+
+	return approver
+}
+
+func ApproverFromBytes(bytes []byte, optionalTargetObject ...*Approver) (result *Approver, err error, consumedBytes int) {
+	marshalUtil := marshalutil.New(bytes)
+	result, err = ParseApprover(marshalUtil, optionalTargetObject...)
+	consumedBytes = marshalUtil.ReadOffset()
+
+	return
+}
+
+func ParseApprover(marshalUtil *marshalutil.MarshalUtil, optionalTargetObject ...*Approver) (result *Approver, err error) {
+	if parsedObject, parseErr := marshalUtil.Parse(func(data []byte) (interface{}, error, int) {
+		return ApproverFromStorageKey(data, optionalTargetObject...)
+	}); parseErr != nil {
+		err = parseErr
+
+		return
+	} else {
+		result = parsedObject.(*Approver)
+	}
+
+	if _, err = marshalUtil.Parse(func(data []byte) (parseResult interface{}, parseErr error, parsedBytes int) {
+		parseErr, parsedBytes = result.UnmarshalObjectStorageValue(data)
+
+		return
+	}); err != nil {
+		return
+	}
+
+	return
+}
+
+func ApproverFromStorageKey(key []byte, optionalTargetObject ...*Approver) (result objectstorage.StorableObject, err error, consumedBytes int) {
+	// determine the target object that will hold the unmarshaled information
+	switch len(optionalTargetObject) {
+	case 0:
+		result = &Approver{}
+	case 1:
+		result = optionalTargetObject[0]
+	default:
+		panic("too many arguments in call to ApproverFromStorageKey")
+	}
+
+	// parse the properties that are stored in the key
+	marshalUtil := marshalutil.New(key)
+	result.(*Approver).referencedMessageId, err = message.ParseId(marshalUtil)
+	if err != nil {
+		return
+	}
+	result.(*Approver).approvingMessageId, err = message.ParseId(marshalUtil)
+	if err != nil {
+		return
+	}
+	consumedBytes = marshalUtil.ReadOffset()
+
+	return
+}
+
+func (approver *Approver) ReferencedMessageId() message.Id {
+	return approver.approvingMessageId
+}
+
+func (approver *Approver) ApprovingMessageId() message.Id {
+	return approver.approvingMessageId
+}
+
+func (approver *Approver) Bytes() []byte {
+	return approver.ObjectStorageKey()
+}
+
+func (approver *Approver) String() string {
+	return stringify.Struct("Approver",
+		stringify.StructField("referencedMessageId", approver.ReferencedMessageId()),
+		stringify.StructField("approvingMessageId", approver.ApprovingMessageId()),
+	)
+}
+
+func (approver *Approver) ObjectStorageKey() []byte {
+	return marshalutil.New().
+		WriteBytes(approver.referencedMessageId.Bytes()).
+		WriteBytes(approver.approvingMessageId.Bytes()).
+		Bytes()
+}
+
+func (approver *Approver) ObjectStorageValue() (result []byte) {
+	return
+}
+
+func (approver *Approver) UnmarshalObjectStorageValue(data []byte) (err error, consumedBytes int) {
+	return
+}
+
+func (approver *Approver) Update(other objectstorage.StorableObject) {
+	panic("approvers should never be overwritten and only stored once to optimize IO")
+}
+
+// interface contract (allow the compiler to check if the implementation has all of the required methods).
+var _ objectstorage.StorableObject = &Approver{}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+// region CachedApprover ///////////////////////////////////////////////////////////////////////////////////////////////
+
+type CachedApprover struct {
+	objectstorage.CachedObject
+}
+
+func (cachedApprover *CachedApprover) Unwrap() *Approver {
+	if untypedObject := cachedApprover.Get(); untypedObject == nil {
+		return nil
+	} else {
+		if typedObject := untypedObject.(*Approver); typedObject == nil || typedObject.IsDeleted() {
+			return nil
+		} else {
+			return typedObject
+		}
+	}
+}
+
+func (cachedApprover *CachedApprover) Consume(consumer func(approver *Approver)) (consumed bool) {
+	return cachedApprover.CachedObject.Consume(func(object objectstorage.StorableObject) {
+		consumer(object.(*Approver))
+	})
+}
+
+type CachedApprovers []*CachedApprover
+
+func (cachedApprovers CachedApprovers) Consume(consumer func(approver *Approver)) (consumed bool) {
+	for _, cachedApprover := range cachedApprovers {
+		consumed = cachedApprover.Consume(func(approver *Approver) {
+			consumer(approver)
+		}) || consumed
+	}
+
+	return
+}
+
+// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/packages/binary/tangle/events.go b/packages/binary/messagelayer/tangle/events.go
similarity index 74%
rename from packages/binary/tangle/events.go
rename to packages/binary/messagelayer/tangle/events.go
index ec056169..4c0a6c54 100644
--- a/packages/binary/tangle/events.go
+++ b/packages/binary/messagelayer/tangle/events.go
@@ -3,8 +3,7 @@ package tangle
 import (
 	"github.com/iotaledger/hive.go/events"
 
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transactionmetadata"
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
 )
 
 type Events struct {
@@ -33,8 +32,8 @@ func transactionIdEvent(handler interface{}, params ...interface{}) {
 }
 
 func cachedTransactionEvent(handler interface{}, params ...interface{}) {
-	handler.(func(*message.CachedTransaction, *transactionmetadata.CachedTransactionMetadata))(
-		params[0].(*message.CachedTransaction).Retain(),
-		params[1].(*transactionmetadata.CachedTransactionMetadata).Retain(),
+	handler.(func(*message.CachedMessage, *CachedMessageMetadata))(
+		params[0].(*message.CachedMessage).Retain(),
+		params[1].(*CachedMessageMetadata).Retain(),
 	)
 }
diff --git a/packages/binary/messagelayer/tangle/messagemetadata.go b/packages/binary/messagelayer/tangle/messagemetadata.go
new file mode 100644
index 00000000..4fd028f1
--- /dev/null
+++ b/packages/binary/messagelayer/tangle/messagemetadata.go
@@ -0,0 +1,171 @@
+package tangle
+
+import (
+	"sync"
+	"time"
+
+	"github.com/iotaledger/hive.go/marshalutil"
+	"github.com/iotaledger/hive.go/objectstorage"
+
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+)
+
+type MessageMetadata struct {
+	objectstorage.StorableObjectFlags
+
+	transactionId      message.Id
+	receivedTime       time.Time
+	solid              bool
+	solidificationTime time.Time
+
+	solidMutex              sync.RWMutex
+	solidificationTimeMutex sync.RWMutex
+}
+
+func NewMessageMetadata(transactionId message.Id) *MessageMetadata {
+	return &MessageMetadata{
+		transactionId: transactionId,
+		receivedTime:  time.Now(),
+	}
+}
+
+func MessageMetadataFromBytes(bytes []byte) (result *MessageMetadata, err error, consumedBytes int) {
+	marshalUtil := marshalutil.New(bytes)
+	result, err = ParseMessageMetadata(marshalUtil)
+	consumedBytes = marshalUtil.ReadOffset()
+
+	return
+}
+
+func ParseMessageMetadata(marshalUtil *marshalutil.MarshalUtil) (result *MessageMetadata, err error) {
+	if parsedObject, parseErr := marshalUtil.Parse(func(data []byte) (interface{}, error, int) {
+		return MessageMetadataFromStorageKey(data)
+	}); parseErr != nil {
+		err = parseErr
+
+		return
+	} else {
+		result = parsedObject.(*MessageMetadata)
+	}
+
+	if _, err = marshalUtil.Parse(func(data []byte) (parseResult interface{}, parseErr error, parsedBytes int) {
+		parseErr, parsedBytes = result.UnmarshalObjectStorageValue(data)
+
+		return
+	}); err != nil {
+		return
+	}
+
+	return
+}
+
+func MessageMetadataFromStorageKey(key []byte) (result objectstorage.StorableObject, err error, consumedBytes int) {
+	result = &MessageMetadata{}
+
+	marshalUtil := marshalutil.New(key)
+	result.(*MessageMetadata).transactionId, err = message.ParseId(marshalUtil)
+	if err != nil {
+		return
+	}
+	consumedBytes = marshalUtil.ReadOffset()
+
+	return
+}
+
+func (messageMetadata *MessageMetadata) IsSolid() (result bool) {
+	messageMetadata.solidMutex.RLock()
+	result = messageMetadata.solid
+	messageMetadata.solidMutex.RUnlock()
+
+	return
+}
+
+func (messageMetadata *MessageMetadata) SetSolid(solid bool) (modified bool) {
+	messageMetadata.solidMutex.RLock()
+	if messageMetadata.solid != solid {
+		messageMetadata.solidMutex.RUnlock()
+
+		messageMetadata.solidMutex.Lock()
+		if messageMetadata.solid != solid {
+			messageMetadata.solid = solid
+			if solid {
+				messageMetadata.solidificationTimeMutex.Lock()
+				messageMetadata.solidificationTime = time.Now()
+				messageMetadata.solidificationTimeMutex.Unlock()
+			}
+
+			messageMetadata.SetModified()
+
+			modified = true
+		}
+		messageMetadata.solidMutex.Unlock()
+
+	} else {
+		messageMetadata.solidMutex.RUnlock()
+	}
+
+	return
+}
+
+func (messageMetadata *MessageMetadata) SoldificationTime() time.Time {
+	messageMetadata.solidificationTimeMutex.RLock()
+	defer messageMetadata.solidificationTimeMutex.RUnlock()
+
+	return messageMetadata.solidificationTime
+}
+
+func (messageMetadata *MessageMetadata) ObjectStorageKey() []byte {
+	return messageMetadata.transactionId.Bytes()
+}
+
+func (messageMetadata *MessageMetadata) ObjectStorageValue() []byte {
+	return marshalutil.New().
+		WriteTime(messageMetadata.receivedTime).
+		WriteTime(messageMetadata.solidificationTime).
+		WriteBool(messageMetadata.solid).
+		Bytes()
+}
+
+func (messageMetadata *MessageMetadata) UnmarshalObjectStorageValue(data []byte) (err error, consumedBytes int) {
+	marshalUtil := marshalutil.New(data)
+
+	if messageMetadata.receivedTime, err = marshalUtil.ReadTime(); err != nil {
+		return
+	}
+	if messageMetadata.solidificationTime, err = marshalUtil.ReadTime(); err != nil {
+		return
+	}
+	if messageMetadata.solid, err = marshalUtil.ReadBool(); err != nil {
+		return
+	}
+
+	consumedBytes = marshalUtil.ReadOffset()
+
+	return
+}
+
+func (messageMetadata *MessageMetadata) Update(other objectstorage.StorableObject) {
+	panic("updates disabled")
+}
+
+var _ objectstorage.StorableObject = &MessageMetadata{}
+
+type CachedMessageMetadata struct {
+	objectstorage.CachedObject
+}
+
+func (cachedMessageMetadata *CachedMessageMetadata) Retain() *CachedMessageMetadata {
+	return &CachedMessageMetadata{cachedMessageMetadata.CachedObject.Retain()}
+}
+
+func (cachedMessageMetadata *CachedMessageMetadata) Unwrap() *MessageMetadata {
+	if untypedObject := cachedMessageMetadata.Get(); untypedObject == nil {
+		return nil
+	} else {
+		if typedObject := untypedObject.(*MessageMetadata); typedObject == nil || typedObject.IsDeleted() {
+			return nil
+		} else {
+			return typedObject
+		}
+	}
+}
diff --git a/packages/binary/messagelayer/tangle/missingmessage.go b/packages/binary/messagelayer/tangle/missingmessage.go
new file mode 100644
index 00000000..e05d11f0
--- /dev/null
+++ b/packages/binary/messagelayer/tangle/missingmessage.go
@@ -0,0 +1,82 @@
+package tangle
+
+import (
+	"time"
+
+	"github.com/iotaledger/hive.go/marshalutil"
+	"github.com/iotaledger/hive.go/objectstorage"
+
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+)
+
+type MissingMessage struct {
+	objectstorage.StorableObjectFlags
+
+	transactionId message.Id
+	missingSince  time.Time
+}
+
+func NewMissingMessage(transactionId message.Id) *MissingMessage {
+	return &MissingMessage{
+		transactionId: transactionId,
+		missingSince:  time.Now(),
+	}
+}
+
+func MissingMessageFromStorageKey(key []byte, optionalTargetObject ...*MissingMessage) (result objectstorage.StorableObject, err error, consumedBytes int) {
+	// determine the target object that will hold the unmarshaled information
+	switch len(optionalTargetObject) {
+	case 0:
+		result = &Approver{}
+	case 1:
+		result = optionalTargetObject[0]
+	default:
+		panic("too many arguments in call to MissingMessageFromStorageKey")
+	}
+
+	// parse the properties that are stored in the key
+	marshalUtil := marshalutil.New(key)
+	result.(*MissingMessage).transactionId, err = message.ParseId(marshalUtil)
+	if err != nil {
+		return
+	}
+	consumedBytes = marshalUtil.ReadOffset()
+
+	return
+}
+
+func (missingMessage *MissingMessage) GetTransactionId() message.Id {
+	return missingMessage.transactionId
+}
+
+func (missingMessage *MissingMessage) GetMissingSince() time.Time {
+	return missingMessage.missingSince
+}
+
+func (missingMessage *MissingMessage) Update(other objectstorage.StorableObject) {
+	panic("missing transactions should never be overwritten and only stored once to optimize IO")
+}
+
+func (missingMessage *MissingMessage) ObjectStorageKey() []byte {
+	return missingMessage.transactionId[:]
+}
+
+func (missingMessage *MissingMessage) ObjectStorageValue() (result []byte) {
+	result, err := missingMessage.missingSince.MarshalBinary()
+	if err != nil {
+		panic(err)
+	}
+
+	return
+}
+
+func (missingMessage *MissingMessage) UnmarshalObjectStorageValue(data []byte) (err error, consumedBytes int) {
+	marshalUtil := marshalutil.New(data)
+	missingMessage.missingSince, err = marshalUtil.ReadTime()
+	if err != nil {
+		return
+	}
+	consumedBytes = marshalUtil.ReadOffset()
+
+	return
+}
diff --git a/packages/binary/tangle/tangle.go b/packages/binary/messagelayer/tangle/tangle.go
similarity index 55%
rename from packages/binary/tangle/tangle.go
rename to packages/binary/messagelayer/tangle/tangle.go
index 3ed82777..8dc9477f 100644
--- a/packages/binary/tangle/tangle.go
+++ b/packages/binary/messagelayer/tangle/tangle.go
@@ -7,11 +7,8 @@ import (
 	"github.com/dgraph-io/badger/v2"
 	"github.com/iotaledger/hive.go/types"
 
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
 	"github.com/iotaledger/goshimmer/packages/binary/storageprefix"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/approver"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/missingtransaction"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transactionmetadata"
 
 	"github.com/iotaledger/hive.go/async"
 	"github.com/iotaledger/hive.go/objectstorage"
@@ -25,26 +22,38 @@ const (
 type Tangle struct {
 	storageId []byte
 
-	transactionStorage         *objectstorage.ObjectStorage
-	transactionMetadataStorage *objectstorage.ObjectStorage
-	approverStorage            *objectstorage.ObjectStorage
-	missingTransactionsStorage *objectstorage.ObjectStorage
+	messageStorage         *objectstorage.ObjectStorage
+	messageMetadataStorage *objectstorage.ObjectStorage
+	approverStorage        *objectstorage.ObjectStorage
+	missingMessageStorage  *objectstorage.ObjectStorage
 
 	Events Events
 
-	storeTransactionsWorkerPool async.WorkerPool
-	solidifierWorkerPool        async.WorkerPool
-	cleanupWorkerPool           async.WorkerPool
+	storeMessageWorkerPool async.WorkerPool
+	solidifierWorkerPool   async.WorkerPool
+	cleanupWorkerPool      async.WorkerPool
+}
+
+func messageFactory(key []byte) (objectstorage.StorableObject, error, int) {
+	return message.StorableObjectFromKey(key)
+}
+
+func approverFactory(key []byte) (objectstorage.StorableObject, error, int) {
+	return ApproverFromStorageKey(key)
+}
+
+func missingMessageFactory(key []byte) (objectstorage.StorableObject, error, int) {
+	return MissingMessageFromStorageKey(key)
 }
 
 // Constructor for the tangle.
 func New(badgerInstance *badger.DB, storageId []byte) (result *Tangle) {
 	result = &Tangle{
-		storageId:                  storageId,
-		transactionStorage:         objectstorage.New(badgerInstance, append(storageId, storageprefix.TangleTransaction...), message.StorableObjectFromKey, objectstorage.CacheTime(10*time.Second), objectstorage.LeakDetectionEnabled(false)),
-		transactionMetadataStorage: objectstorage.New(badgerInstance, append(storageId, storageprefix.TangleTransactionMetadata...), transactionmetadata.StorableObjectFromKey, objectstorage.CacheTime(10*time.Second), objectstorage.LeakDetectionEnabled(false)),
-		approverStorage:            objectstorage.New(badgerInstance, append(storageId, storageprefix.TangleApprovers...), approver.StorableObjectFromKey, objectstorage.CacheTime(10*time.Second), objectstorage.PartitionKey(message.IdLength, message.IdLength), objectstorage.LeakDetectionEnabled(false)),
-		missingTransactionsStorage: objectstorage.New(badgerInstance, append(storageId, storageprefix.TangleMissingTransaction...), missingtransaction.StorableObjectFromKey, objectstorage.CacheTime(10*time.Second), objectstorage.LeakDetectionEnabled(false)),
+		storageId:              storageId,
+		messageStorage:         objectstorage.New(badgerInstance, append(storageId, storageprefix.Layer0Message...), messageFactory, objectstorage.CacheTime(10*time.Second), objectstorage.LeakDetectionEnabled(false)),
+		messageMetadataStorage: objectstorage.New(badgerInstance, append(storageId, storageprefix.Layer0MessageMetadata...), MessageMetadataFromStorageKey, objectstorage.CacheTime(10*time.Second), objectstorage.LeakDetectionEnabled(false)),
+		approverStorage:        objectstorage.New(badgerInstance, append(storageId, storageprefix.Layer0Approvers...), approverFactory, objectstorage.CacheTime(10*time.Second), objectstorage.PartitionKey(message.IdLength, message.IdLength), objectstorage.LeakDetectionEnabled(false)),
+		missingMessageStorage:  objectstorage.New(badgerInstance, append(storageId, storageprefix.Layer0MissingMessage...), missingMessageFactory, objectstorage.CacheTime(10*time.Second), objectstorage.LeakDetectionEnabled(false)),
 
 		Events: *newEvents(),
 	}
@@ -55,30 +64,30 @@ func New(badgerInstance *badger.DB, storageId []byte) (result *Tangle) {
 }
 
 // Returns the storage id of this tangle (can be used to create ontologies that follow the storage of the main tangle).
-func (tangle *Tangle) GetStorageId() []byte {
+func (tangle *Tangle) StorageId() []byte {
 	return tangle.storageId
 }
 
 // Attaches a new transaction to the tangle.
-func (tangle *Tangle) AttachTransaction(transaction *message.Transaction) {
-	tangle.storeTransactionsWorkerPool.Submit(func() { tangle.storeTransactionWorker(transaction) })
+func (tangle *Tangle) AttachMessage(transaction *message.Message) {
+	tangle.storeMessageWorkerPool.Submit(func() { tangle.storeMessageWorker(transaction) })
 }
 
 // Retrieves a transaction from the tangle.
-func (tangle *Tangle) GetTransaction(transactionId message.Id) *message.CachedTransaction {
-	return &message.CachedTransaction{CachedObject: tangle.transactionStorage.Load(transactionId[:])}
+func (tangle *Tangle) Message(transactionId message.Id) *message.CachedMessage {
+	return &message.CachedMessage{CachedObject: tangle.messageStorage.Load(transactionId[:])}
 }
 
 // Retrieves the metadata of a transaction from the tangle.
-func (tangle *Tangle) GetTransactionMetadata(transactionId message.Id) *transactionmetadata.CachedTransactionMetadata {
-	return &transactionmetadata.CachedTransactionMetadata{CachedObject: tangle.transactionMetadataStorage.Load(transactionId[:])}
+func (tangle *Tangle) MessageMetadata(transactionId message.Id) *CachedMessageMetadata {
+	return &CachedMessageMetadata{CachedObject: tangle.messageMetadataStorage.Load(transactionId[:])}
 }
 
-// GetApprovers retrieves the approvers of a transaction from the tangle.
-func (tangle *Tangle) GetApprovers(transactionId message.Id) approver.CachedApprovers {
-	approvers := make(approver.CachedApprovers, 0)
+// Approvers retrieves the approvers of a transaction from the tangle.
+func (tangle *Tangle) Approvers(transactionId message.Id) CachedApprovers {
+	approvers := make(CachedApprovers, 0)
 	tangle.approverStorage.ForEach(func(key []byte, cachedObject objectstorage.CachedObject) bool {
-		approvers = append(approvers, &approver.CachedApprover{CachedObject: cachedObject})
+		approvers = append(approvers, &CachedApprover{CachedObject: cachedObject})
 
 		return true
 	}, transactionId[:])
@@ -87,33 +96,33 @@ func (tangle *Tangle) GetApprovers(transactionId message.Id) approver.CachedAppr
 }
 
 // Deletes a transaction from the tangle (i.e. for local snapshots)
-func (tangle *Tangle) DeleteTransaction(transactionId message.Id) {
-	tangle.GetTransaction(transactionId).Consume(func(currentTransaction *message.Transaction) {
+func (tangle *Tangle) DeleteMessage(messageId message.Id) {
+	tangle.Message(messageId).Consume(func(currentTransaction *message.Message) {
 		trunkTransactionId := currentTransaction.GetTrunkTransactionId()
-		tangle.deleteApprover(trunkTransactionId, transactionId)
+		tangle.deleteApprover(trunkTransactionId, messageId)
 
 		branchTransactionId := currentTransaction.GetBranchTransactionId()
 		if branchTransactionId != trunkTransactionId {
-			tangle.deleteApprover(branchTransactionId, transactionId)
+			tangle.deleteApprover(branchTransactionId, messageId)
 		}
 
-		tangle.transactionMetadataStorage.Delete(transactionId[:])
-		tangle.transactionStorage.Delete(transactionId[:])
+		tangle.messageMetadataStorage.Delete(messageId[:])
+		tangle.messageStorage.Delete(messageId[:])
 
-		tangle.Events.TransactionRemoved.Trigger(transactionId)
+		tangle.Events.TransactionRemoved.Trigger(messageId)
 	})
 }
 
 // Marks the tangle as stopped, so it will not accept any new transactions (waits for all backgroundTasks to finish.
 func (tangle *Tangle) Shutdown() *Tangle {
-	tangle.storeTransactionsWorkerPool.ShutdownGracefully()
+	tangle.storeMessageWorkerPool.ShutdownGracefully()
 	tangle.solidifierWorkerPool.ShutdownGracefully()
 	tangle.cleanupWorkerPool.ShutdownGracefully()
 
-	tangle.transactionStorage.Shutdown()
-	tangle.transactionMetadataStorage.Shutdown()
+	tangle.messageStorage.Shutdown()
+	tangle.messageMetadataStorage.Shutdown()
 	tangle.approverStorage.Shutdown()
-	tangle.missingTransactionsStorage.Shutdown()
+	tangle.missingMessageStorage.Shutdown()
 
 	return tangle
 }
@@ -121,10 +130,10 @@ func (tangle *Tangle) Shutdown() *Tangle {
 // Resets the database and deletes all objects (good for testing or "node resets").
 func (tangle *Tangle) Prune() error {
 	for _, storage := range []*objectstorage.ObjectStorage{
-		tangle.transactionStorage,
-		tangle.transactionMetadataStorage,
+		tangle.messageStorage,
+		tangle.messageMetadataStorage,
 		tangle.approverStorage,
-		tangle.missingTransactionsStorage,
+		tangle.missingMessageStorage,
 	} {
 		if err := storage.Prune(); err != nil {
 			return err
@@ -135,55 +144,55 @@ func (tangle *Tangle) Prune() error {
 }
 
 // Worker that stores the transactions and calls the corresponding storage events"
-func (tangle *Tangle) storeTransactionWorker(tx *message.Transaction) {
+func (tangle *Tangle) storeMessageWorker(tx *message.Message) {
 	// store transaction
-	var cachedTransaction *message.CachedTransaction
-	if _tmp, transactionIsNew := tangle.transactionStorage.StoreIfAbsent(tx); !transactionIsNew {
+	var cachedTransaction *message.CachedMessage
+	if _tmp, transactionIsNew := tangle.messageStorage.StoreIfAbsent(tx); !transactionIsNew {
 		return
 	} else {
-		cachedTransaction = &message.CachedTransaction{CachedObject: _tmp}
+		cachedTransaction = &message.CachedMessage{CachedObject: _tmp}
 	}
 
 	// store transaction metadata
 	transactionId := tx.GetId()
-	cachedTransactionMetadata := &transactionmetadata.CachedTransactionMetadata{CachedObject: tangle.transactionMetadataStorage.Store(transactionmetadata.New(transactionId))}
+	cachedTransactionMetadata := &CachedMessageMetadata{CachedObject: tangle.messageMetadataStorage.Store(NewMessageMetadata(transactionId))}
 
 	// store trunk approver
 	trunkTransactionID := tx.GetTrunkTransactionId()
-	tangle.approverStorage.Store(approver.New(trunkTransactionID, transactionId)).Release()
+	tangle.approverStorage.Store(NewApprover(trunkTransactionID, transactionId)).Release()
 
 	// store branch approver
 	if branchTransactionID := tx.GetBranchTransactionId(); branchTransactionID != trunkTransactionID {
-		tangle.approverStorage.Store(approver.New(branchTransactionID, transactionId)).Release()
+		tangle.approverStorage.Store(NewApprover(branchTransactionID, transactionId)).Release()
 	}
 
 	// trigger events
-	if tangle.missingTransactionsStorage.DeleteIfPresent(transactionId[:]) {
+	if tangle.missingMessageStorage.DeleteIfPresent(transactionId[:]) {
 		tangle.Events.MissingTransactionReceived.Trigger(cachedTransaction, cachedTransactionMetadata)
 	}
 	tangle.Events.TransactionAttached.Trigger(cachedTransaction, cachedTransactionMetadata)
 
 	// check solidity
 	tangle.solidifierWorkerPool.Submit(func() {
-		tangle.solidifyTransactionWorker(cachedTransaction, cachedTransactionMetadata)
+		tangle.solidifyMessageWorker(cachedTransaction, cachedTransactionMetadata)
 	})
 }
 
 // Worker that solidifies the transactions (recursively from past to present).
-func (tangle *Tangle) solidifyTransactionWorker(cachedTransaction *message.CachedTransaction, cachedTransactionMetadata *transactionmetadata.CachedTransactionMetadata) {
+func (tangle *Tangle) solidifyMessageWorker(cachedTransaction *message.CachedMessage, cachedTransactionMetadata *CachedMessageMetadata) {
 	isTransactionMarkedAsSolid := func(transactionId message.Id) bool {
 		if transactionId == message.EmptyId {
 			return true
 		}
 
-		transactionMetadataCached := tangle.GetTransactionMetadata(transactionId)
+		transactionMetadataCached := tangle.MessageMetadata(transactionId)
 		if transactionMetadata := transactionMetadataCached.Unwrap(); transactionMetadata == nil {
 			transactionMetadataCached.Release()
 
 			// if transaction is missing and was not reported as missing, yet
-			if cachedMissingTransaction, missingTransactionStored := tangle.missingTransactionsStorage.StoreIfAbsent(missingtransaction.New(transactionId)); missingTransactionStored {
+			if cachedMissingTransaction, missingTransactionStored := tangle.missingMessageStorage.StoreIfAbsent(NewMissingMessage(transactionId)); missingTransactionStored {
 				cachedMissingTransaction.Consume(func(object objectstorage.StorableObject) {
-					tangle.monitorMissingTransactionWorker(object.(*missingtransaction.MissingTransaction).GetTransactionId())
+					tangle.monitorMissingMessageWorker(object.(*MissingMessage).GetTransactionId())
 				})
 			}
 
@@ -198,7 +207,7 @@ func (tangle *Tangle) solidifyTransactionWorker(cachedTransaction *message.Cache
 		return true
 	}
 
-	isTransactionSolid := func(transaction *message.Transaction, transactionMetadata *transactionmetadata.TransactionMetadata) bool {
+	isTransactionSolid := func(transaction *message.Message, transactionMetadata *MessageMetadata) bool {
 		if transaction == nil || transaction.IsDeleted() {
 			return false
 		}
@@ -214,13 +223,13 @@ func (tangle *Tangle) solidifyTransactionWorker(cachedTransaction *message.Cache
 		return isTransactionMarkedAsSolid(transaction.GetTrunkTransactionId()) && isTransactionMarkedAsSolid(transaction.GetBranchTransactionId())
 	}
 
-	popElementsFromStack := func(stack *list.List) (*message.CachedTransaction, *transactionmetadata.CachedTransactionMetadata) {
+	popElementsFromStack := func(stack *list.List) (*message.CachedMessage, *CachedMessageMetadata) {
 		currentSolidificationEntry := stack.Front()
 		currentCachedTransaction := currentSolidificationEntry.Value.([2]interface{})[0]
 		currentCachedTransactionMetadata := currentSolidificationEntry.Value.([2]interface{})[1]
 		stack.Remove(currentSolidificationEntry)
 
-		return currentCachedTransaction.(*message.CachedTransaction), currentCachedTransactionMetadata.(*transactionmetadata.CachedTransactionMetadata)
+		return currentCachedTransaction.(*message.CachedMessage), currentCachedTransactionMetadata.(*CachedMessageMetadata)
 	}
 
 	// initialize the stack
@@ -244,12 +253,12 @@ func (tangle *Tangle) solidifyTransactionWorker(cachedTransaction *message.Cache
 		if isTransactionSolid(currentTransaction, currentTransactionMetadata) && currentTransactionMetadata.SetSolid(true) {
 			tangle.Events.TransactionSolid.Trigger(currentCachedTransaction, currentCachedTransactionMetadata)
 
-			tangle.GetApprovers(currentTransaction.GetId()).Consume(func(approver *approver.Approver) {
-				approverTransactionId := approver.GetApprovingTransactionId()
+			tangle.Approvers(currentTransaction.GetId()).Consume(func(approver *Approver) {
+				approverTransactionId := approver.ReferencedMessageId()
 
 				solidificationStack.PushBack([2]interface{}{
-					tangle.GetTransaction(approverTransactionId),
-					tangle.GetTransactionMetadata(approverTransactionId),
+					tangle.Message(approverTransactionId),
+					tangle.MessageMetadata(approverTransactionId),
 				})
 			})
 		}
@@ -261,12 +270,12 @@ func (tangle *Tangle) solidifyTransactionWorker(cachedTransaction *message.Cache
 }
 
 // Worker that Monitors the missing transactions (by scheduling regular checks).
-func (tangle *Tangle) monitorMissingTransactionWorker(transactionId message.Id) {
+func (tangle *Tangle) monitorMissingMessageWorker(transactionId message.Id) {
 	var scheduleNextMissingCheck func(transactionId message.Id)
 	scheduleNextMissingCheck = func(transactionId message.Id) {
 		time.AfterFunc(MISSING_CHECK_INTERVAL, func() {
-			tangle.missingTransactionsStorage.Load(transactionId[:]).Consume(func(object objectstorage.StorableObject) {
-				missingTransaction := object.(*missingtransaction.MissingTransaction)
+			tangle.missingMessageStorage.Load(transactionId[:]).Consume(func(object objectstorage.StorableObject) {
+				missingTransaction := object.(*MissingMessage)
 
 				if time.Since(missingTransaction.GetMissingSince()) >= MAX_MISSING_TIME_BEFORE_CLEANUP {
 					tangle.cleanupWorkerPool.Submit(func() {
@@ -308,10 +317,10 @@ func (tangle *Tangle) deleteSubtangle(transactionId message.Id) {
 		currentTransactionId := currentStackEntry.Value.(message.Id)
 		cleanupStack.Remove(currentStackEntry)
 
-		tangle.DeleteTransaction(currentTransactionId)
+		tangle.DeleteMessage(currentTransactionId)
 
-		tangle.GetApprovers(currentTransactionId).Consume(func(approver *approver.Approver) {
-			approverId := approver.GetApprovingTransactionId()
+		tangle.Approvers(currentTransactionId).Consume(func(approver *Approver) {
+			approverId := approver.ReferencedMessageId()
 
 			if _, transactionProcessed := processedTransactions[approverId]; !transactionProcessed {
 				cleanupStack.PushBack(approverId)
diff --git a/packages/binary/tangle/tangle_test.go b/packages/binary/messagelayer/tangle/tangle_test.go
similarity index 52%
rename from packages/binary/tangle/tangle_test.go
rename to packages/binary/messagelayer/tangle/tangle_test.go
index 9cf607e6..40a263f6 100644
--- a/packages/binary/tangle/tangle_test.go
+++ b/packages/binary/messagelayer/tangle/tangle_test.go
@@ -10,10 +10,9 @@ import (
 	"github.com/iotaledger/hive.go/events"
 	"github.com/stretchr/testify/require"
 
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/payload"
 	"github.com/iotaledger/goshimmer/packages/binary/signature/ed25119"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message/payload/data"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transactionmetadata"
 	"github.com/iotaledger/goshimmer/packages/database"
 	"github.com/iotaledger/goshimmer/plugins/config"
 )
@@ -34,16 +33,16 @@ func BenchmarkTangle_AttachTransaction(b *testing.B) {
 
 	testIdentity := ed25119.GenerateKeyPair()
 
-	transactionBytes := make([]*message.Transaction, b.N)
+	transactionBytes := make([]*message.Message, b.N)
 	for i := 0; i < b.N; i++ {
-		transactionBytes[i] = message.New(message.EmptyId, message.EmptyId, testIdentity, time.Now(), 0, data.New([]byte("some data")))
+		transactionBytes[i] = message.New(message.EmptyId, message.EmptyId, testIdentity, time.Now(), 0, payload.NewData([]byte("some data")))
 		transactionBytes[i].Bytes()
 	}
 
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
-		tangle.AttachTransaction(transactionBytes[i])
+		tangle.AttachMessage(transactionBytes[i])
 	}
 
 	tangle.Shutdown()
@@ -56,49 +55,49 @@ func TestTangle_AttachTransaction(t *testing.T) {
 	// use the tempdir for the database
 	config.Node.Set(database.CFG_DIRECTORY, dir)
 
-	tangle := New(database.GetBadgerInstance(), []byte("TEST_BINARY_TANGLE"))
-	if err := tangle.Prune(); err != nil {
+	messageTangle := New(database.GetBadgerInstance(), []byte("TEST_BINARY_TANGLE"))
+	if err := messageTangle.Prune(); err != nil {
 		t.Error(err)
 
 		return
 	}
 
-	tangle.Events.TransactionAttached.Attach(events.NewClosure(func(cachedTransaction *message.CachedTransaction, cachedTransactionMetadata *transactionmetadata.CachedTransactionMetadata) {
+	messageTangle.Events.TransactionAttached.Attach(events.NewClosure(func(cachedTransaction *message.CachedMessage, cachedTransactionMetadata *CachedMessageMetadata) {
 		cachedTransactionMetadata.Release()
 
-		cachedTransaction.Consume(func(transaction *message.Transaction) {
+		cachedTransaction.Consume(func(transaction *message.Message) {
 			fmt.Println("ATTACHED:", transaction.GetId())
 		})
 	}))
 
-	tangle.Events.TransactionSolid.Attach(events.NewClosure(func(cachedTransaction *message.CachedTransaction, cachedTransactionMetadata *transactionmetadata.CachedTransactionMetadata) {
+	messageTangle.Events.TransactionSolid.Attach(events.NewClosure(func(cachedTransaction *message.CachedMessage, cachedTransactionMetadata *CachedMessageMetadata) {
 		cachedTransactionMetadata.Release()
 
-		cachedTransaction.Consume(func(transaction *message.Transaction) {
+		cachedTransaction.Consume(func(transaction *message.Message) {
 			fmt.Println("SOLID:", transaction.GetId())
 		})
 	}))
 
-	tangle.Events.TransactionUnsolidifiable.Attach(events.NewClosure(func(transactionId message.Id) {
+	messageTangle.Events.TransactionUnsolidifiable.Attach(events.NewClosure(func(transactionId message.Id) {
 		fmt.Println("UNSOLIDIFIABLE:", transactionId)
 	}))
 
-	tangle.Events.TransactionMissing.Attach(events.NewClosure(func(transactionId message.Id) {
+	messageTangle.Events.TransactionMissing.Attach(events.NewClosure(func(transactionId message.Id) {
 		fmt.Println("MISSING:", transactionId)
 	}))
 
-	tangle.Events.TransactionRemoved.Attach(events.NewClosure(func(transactionId message.Id) {
+	messageTangle.Events.TransactionRemoved.Attach(events.NewClosure(func(transactionId message.Id) {
 		fmt.Println("REMOVED:", transactionId)
 	}))
 
-	newTransaction1 := message.New(message.EmptyId, message.EmptyId, ed25119.GenerateKeyPair(), time.Now(), 0, data.New([]byte("some data")))
-	newTransaction2 := message.New(newTransaction1.GetId(), newTransaction1.GetId(), ed25119.GenerateKeyPair(), time.Now(), 0, data.New([]byte("some other data")))
+	newTransaction1 := message.New(message.EmptyId, message.EmptyId, ed25119.GenerateKeyPair(), time.Now(), 0, payload.NewData([]byte("some data")))
+	newTransaction2 := message.New(newTransaction1.GetId(), newTransaction1.GetId(), ed25119.GenerateKeyPair(), time.Now(), 0, payload.NewData([]byte("some other data")))
 
-	tangle.AttachTransaction(newTransaction2)
+	messageTangle.AttachMessage(newTransaction2)
 
 	time.Sleep(7 * time.Second)
 
-	tangle.AttachTransaction(newTransaction1)
+	messageTangle.AttachMessage(newTransaction1)
 
-	tangle.Shutdown()
+	messageTangle.Shutdown()
 }
diff --git a/packages/binary/tangle/model/message/test/transaction_test.go b/packages/binary/messagelayer/test/transaction_test.go
similarity index 78%
rename from packages/binary/tangle/model/message/test/transaction_test.go
rename to packages/binary/messagelayer/test/transaction_test.go
index be5a61ff..6881c27c 100644
--- a/packages/binary/tangle/model/message/test/transaction_test.go
+++ b/packages/binary/messagelayer/test/transaction_test.go
@@ -10,9 +10,9 @@ import (
 
 	"github.com/panjf2000/ants/v2"
 
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/payload"
 	"github.com/iotaledger/goshimmer/packages/binary/signature/ed25119"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message/payload/data"
 )
 
 func BenchmarkVerifyDataTransactions(b *testing.B) {
@@ -21,7 +21,7 @@ func BenchmarkVerifyDataTransactions(b *testing.B) {
 
 	transactions := make([][]byte, b.N)
 	for i := 0; i < b.N; i++ {
-		tx := message.New(message.EmptyId, message.EmptyId, ed25119.GenerateKeyPair(), time.Now(), 0, data.New([]byte("some data")))
+		tx := message.New(message.EmptyId, message.EmptyId, ed25119.GenerateKeyPair(), time.Now(), 0, payload.NewData([]byte("some data")))
 
 		transactions[i] = tx.Bytes()
 	}
@@ -45,9 +45,9 @@ func BenchmarkVerifyDataTransactions(b *testing.B) {
 func BenchmarkVerifySignature(b *testing.B) {
 	pool, _ := ants.NewPool(80, ants.WithNonblocking(false))
 
-	transactions := make([]*message.Transaction, b.N)
+	transactions := make([]*message.Message, b.N)
 	for i := 0; i < b.N; i++ {
-		transactions[i] = message.New(message.EmptyId, message.EmptyId, ed25119.GenerateKeyPair(), time.Now(), 0, data.New([]byte("test")))
+		transactions[i] = message.New(message.EmptyId, message.EmptyId, ed25119.GenerateKeyPair(), time.Now(), 0, payload.NewData([]byte("test")))
 		transactions[i].Bytes()
 	}
 
diff --git a/packages/binary/tangle/tipselector/events.go b/packages/binary/messagelayer/tipselector/events.go
similarity index 81%
rename from packages/binary/tangle/tipselector/events.go
rename to packages/binary/messagelayer/tipselector/events.go
index 21f6276e..432f2914 100644
--- a/packages/binary/tangle/tipselector/events.go
+++ b/packages/binary/messagelayer/tipselector/events.go
@@ -1,8 +1,9 @@
 package tipselector
 
 import (
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
 	"github.com/iotaledger/hive.go/events"
+
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
 )
 
 type Events struct {
diff --git a/packages/binary/tangle/tipselector/tipselector.go b/packages/binary/messagelayer/tipselector/tipselector.go
similarity index 92%
rename from packages/binary/tangle/tipselector/tipselector.go
rename to packages/binary/messagelayer/tipselector/tipselector.go
index f98d1f50..84e447d8 100644
--- a/packages/binary/tangle/tipselector/tipselector.go
+++ b/packages/binary/messagelayer/tipselector/tipselector.go
@@ -1,9 +1,10 @@
 package tipselector
 
 import (
-	"github.com/iotaledger/goshimmer/packages/binary/datastructure"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
 	"github.com/iotaledger/hive.go/events"
+
+	"github.com/iotaledger/goshimmer/packages/binary/datastructure"
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
 )
 
 type TipSelector struct {
@@ -21,7 +22,7 @@ func New() *TipSelector {
 	}
 }
 
-func (tipSelector *TipSelector) AddTip(transaction *message.Transaction) {
+func (tipSelector *TipSelector) AddTip(transaction *message.Message) {
 	transactionId := transaction.GetId()
 	if tipSelector.tips.Set(transactionId, transactionId) {
 		tipSelector.Events.TipAdded.Trigger(transactionId)
diff --git a/packages/binary/tangle/tipselector/tipselector_test.go b/packages/binary/messagelayer/tipselector/tipselector_test.go
similarity index 80%
rename from packages/binary/tangle/tipselector/tipselector_test.go
rename to packages/binary/messagelayer/tipselector/tipselector_test.go
index f089f29d..9adda6fc 100644
--- a/packages/binary/tangle/tipselector/tipselector_test.go
+++ b/packages/binary/messagelayer/tipselector/tipselector_test.go
@@ -6,9 +6,9 @@ import (
 
 	"github.com/stretchr/testify/assert"
 
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/payload"
 	"github.com/iotaledger/goshimmer/packages/binary/signature/ed25119"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message/payload/data"
 )
 
 func Test(t *testing.T) {
@@ -21,7 +21,7 @@ func Test(t *testing.T) {
 	assert.Equal(t, message.EmptyId, branch1)
 
 	// create a transaction and attach it
-	transaction1 := message.New(trunk1, branch1, ed25119.GenerateKeyPair(), time.Now(), 0, data.New([]byte("testtransaction")))
+	transaction1 := message.New(trunk1, branch1, ed25119.GenerateKeyPair(), time.Now(), 0, payload.NewData([]byte("testtransaction")))
 	tipSelector.AddTip(transaction1)
 
 	// check if the tip shows up in the tip count
@@ -33,7 +33,7 @@ func Test(t *testing.T) {
 	assert.Equal(t, transaction1.GetId(), branch2)
 
 	// create a 2nd transaction and attach it
-	transaction2 := message.New(message.EmptyId, message.EmptyId, ed25119.GenerateKeyPair(), time.Now(), 0, data.New([]byte("testtransaction")))
+	transaction2 := message.New(message.EmptyId, message.EmptyId, ed25119.GenerateKeyPair(), time.Now(), 0, payload.NewData([]byte("testtransaction")))
 	tipSelector.AddTip(transaction2)
 
 	// check if the tip shows up in the tip count
@@ -41,7 +41,7 @@ func Test(t *testing.T) {
 
 	// attach a transaction to our two tips
 	trunk3, branch3 := tipSelector.GetTips()
-	transaction3 := message.New(trunk3, branch3, ed25119.GenerateKeyPair(), time.Now(), 0, data.New([]byte("testtransaction")))
+	transaction3 := message.New(trunk3, branch3, ed25119.GenerateKeyPair(), time.Now(), 0, payload.NewData([]byte("testtransaction")))
 	tipSelector.AddTip(transaction3)
 
 	// check if the tip shows replaces the current tips
diff --git a/packages/binary/tangle/transactionparser/builtinfilters/recently_seen_bytes_filter.go b/packages/binary/messagelayer/transactionparser/builtinfilters/recently_seen_bytes_filter.go
similarity index 100%
rename from packages/binary/tangle/transactionparser/builtinfilters/recently_seen_bytes_filter.go
rename to packages/binary/messagelayer/transactionparser/builtinfilters/recently_seen_bytes_filter.go
diff --git a/packages/binary/tangle/transactionparser/builtinfilters/transaction_signature_filter.go b/packages/binary/messagelayer/transactionparser/builtinfilters/transaction_signature_filter.go
similarity index 74%
rename from packages/binary/tangle/transactionparser/builtinfilters/transaction_signature_filter.go
rename to packages/binary/messagelayer/transactionparser/builtinfilters/transaction_signature_filter.go
index f6d64f3e..347c7c31 100644
--- a/packages/binary/tangle/transactionparser/builtinfilters/transaction_signature_filter.go
+++ b/packages/binary/messagelayer/transactionparser/builtinfilters/transaction_signature_filter.go
@@ -7,14 +7,14 @@ import (
 	"github.com/iotaledger/hive.go/async"
 	"github.com/iotaledger/hive.go/autopeering/peer"
 
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
 )
 
 var ErrInvalidSignature = fmt.Errorf("invalid signature")
 
 type TransactionSignatureFilter struct {
-	onAcceptCallback func(tx *message.Transaction, peer *peer.Peer)
-	onRejectCallback func(tx *message.Transaction, err error, peer *peer.Peer)
+	onAcceptCallback func(tx *message.Message, peer *peer.Peer)
+	onRejectCallback func(tx *message.Message, err error, peer *peer.Peer)
 	workerPool       async.WorkerPool
 
 	onAcceptCallbackMutex sync.RWMutex
@@ -27,7 +27,7 @@ func NewTransactionSignatureFilter() (result *TransactionSignatureFilter) {
 	return
 }
 
-func (filter *TransactionSignatureFilter) Filter(tx *message.Transaction, peer *peer.Peer) {
+func (filter *TransactionSignatureFilter) Filter(tx *message.Message, peer *peer.Peer) {
 	filter.workerPool.Submit(func() {
 		if tx.VerifySignature() {
 			filter.getAcceptCallback()(tx, peer)
@@ -37,13 +37,13 @@ func (filter *TransactionSignatureFilter) Filter(tx *message.Transaction, peer *
 	})
 }
 
-func (filter *TransactionSignatureFilter) OnAccept(callback func(tx *message.Transaction, peer *peer.Peer)) {
+func (filter *TransactionSignatureFilter) OnAccept(callback func(tx *message.Message, peer *peer.Peer)) {
 	filter.onAcceptCallbackMutex.Lock()
 	filter.onAcceptCallback = callback
 	filter.onAcceptCallbackMutex.Unlock()
 }
 
-func (filter *TransactionSignatureFilter) OnReject(callback func(tx *message.Transaction, err error, peer *peer.Peer)) {
+func (filter *TransactionSignatureFilter) OnReject(callback func(tx *message.Message, err error, peer *peer.Peer)) {
 	filter.onRejectCallbackMutex.Lock()
 	filter.onRejectCallback = callback
 	filter.onRejectCallbackMutex.Unlock()
@@ -53,7 +53,7 @@ func (filter *TransactionSignatureFilter) Shutdown() {
 	filter.workerPool.ShutdownGracefully()
 }
 
-func (filter *TransactionSignatureFilter) getAcceptCallback() (result func(tx *message.Transaction, peer *peer.Peer)) {
+func (filter *TransactionSignatureFilter) getAcceptCallback() (result func(tx *message.Message, peer *peer.Peer)) {
 	filter.onAcceptCallbackMutex.RLock()
 	result = filter.onAcceptCallback
 	filter.onAcceptCallbackMutex.RUnlock()
@@ -61,7 +61,7 @@ func (filter *TransactionSignatureFilter) getAcceptCallback() (result func(tx *m
 	return
 }
 
-func (filter *TransactionSignatureFilter) getRejectCallback() (result func(tx *message.Transaction, err error, peer *peer.Peer)) {
+func (filter *TransactionSignatureFilter) getRejectCallback() (result func(tx *message.Message, err error, peer *peer.Peer)) {
 	filter.onRejectCallbackMutex.RLock()
 	result = filter.onRejectCallback
 	filter.onRejectCallbackMutex.RUnlock()
diff --git a/packages/binary/tangle/transactionparser/bytes_filter.go b/packages/binary/messagelayer/transactionparser/bytes_filter.go
similarity index 100%
rename from packages/binary/tangle/transactionparser/bytes_filter.go
rename to packages/binary/messagelayer/transactionparser/bytes_filter.go
diff --git a/packages/binary/tangle/transactionparser/events.go b/packages/binary/messagelayer/transactionparser/events.go
similarity index 100%
rename from packages/binary/tangle/transactionparser/events.go
rename to packages/binary/messagelayer/transactionparser/events.go
diff --git a/packages/binary/messagelayer/transactionparser/transaction_filter.go b/packages/binary/messagelayer/transactionparser/transaction_filter.go
new file mode 100644
index 00000000..0cb631ae
--- /dev/null
+++ b/packages/binary/messagelayer/transactionparser/transaction_filter.go
@@ -0,0 +1,14 @@
+package transactionparser
+
+import (
+	"github.com/iotaledger/hive.go/autopeering/peer"
+
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+)
+
+type TransactionFilter interface {
+	Filter(tx *message.Message, peer *peer.Peer)
+	OnAccept(callback func(tx *message.Message, peer *peer.Peer))
+	OnReject(callback func(tx *message.Message, err error, peer *peer.Peer))
+	Shutdown()
+}
diff --git a/packages/binary/tangle/transactionparser/transactionparser.go b/packages/binary/messagelayer/transactionparser/transactionparser.go
similarity index 90%
rename from packages/binary/tangle/transactionparser/transactionparser.go
rename to packages/binary/messagelayer/transactionparser/transactionparser.go
index d684efc3..6e54add7 100644
--- a/packages/binary/tangle/transactionparser/transactionparser.go
+++ b/packages/binary/messagelayer/transactionparser/transactionparser.go
@@ -3,11 +3,10 @@ package transactionparser
 import (
 	"sync"
 
-	"github.com/iotaledger/hive.go/autopeering/peer"
-
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/transactionparser/builtinfilters"
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/transactionparser/builtinfilters"
 
+	"github.com/iotaledger/hive.go/autopeering/peer"
 	"github.com/iotaledger/hive.go/events"
 	"github.com/iotaledger/hive.go/typeutils"
 )
@@ -33,10 +32,10 @@ func New() (result *TransactionParser) {
 				handler.(func([]byte, error, *peer.Peer))(params[0].([]byte), params[1].(error), params[2].(*peer.Peer))
 			}),
 			TransactionParsed: events.NewEvent(func(handler interface{}, params ...interface{}) {
-				handler.(func(*message.Transaction, *peer.Peer))(params[0].(*message.Transaction), params[1].(*peer.Peer))
+				handler.(func(*message.Message, *peer.Peer))(params[0].(*message.Message), params[1].(*peer.Peer))
 			}),
 			TransactionRejected: events.NewEvent(func(handler interface{}, params ...interface{}) {
-				handler.(func(*message.Transaction, error, *peer.Peer))(params[0].(*message.Transaction), params[1].(error), params[2].(*peer.Peer))
+				handler.(func(*message.Message, error, *peer.Peer))(params[0].(*message.Message), params[1].(error), params[2].(*peer.Peer))
 			}),
 		},
 	}
@@ -121,13 +120,13 @@ func (transactionParser *TransactionParser) setupTransactionsFilterDataFlow() {
 		numberOfTransactionFilters := len(transactionParser.transactionFilters)
 		for i := 0; i < numberOfTransactionFilters; i++ {
 			if i == numberOfTransactionFilters-1 {
-				transactionParser.transactionFilters[i].OnAccept(func(tx *message.Transaction, peer *peer.Peer) {
+				transactionParser.transactionFilters[i].OnAccept(func(tx *message.Message, peer *peer.Peer) {
 					transactionParser.Events.TransactionParsed.Trigger(tx, peer)
 				})
 			} else {
 				transactionParser.transactionFilters[i].OnAccept(transactionParser.transactionFilters[i+1].Filter)
 			}
-			transactionParser.transactionFilters[i].OnReject(func(tx *message.Transaction, err error, peer *peer.Peer) {
+			transactionParser.transactionFilters[i].OnReject(func(tx *message.Message, err error, peer *peer.Peer) {
 				transactionParser.Events.TransactionRejected.Trigger(tx, err, peer)
 			})
 		}
diff --git a/packages/binary/tangle/transactionparser/transactionparser_test.go b/packages/binary/messagelayer/transactionparser/transactionparser_test.go
similarity index 72%
rename from packages/binary/tangle/transactionparser/transactionparser_test.go
rename to packages/binary/messagelayer/transactionparser/transactionparser_test.go
index 9a5f6413..eb0c4af4 100644
--- a/packages/binary/tangle/transactionparser/transactionparser_test.go
+++ b/packages/binary/messagelayer/transactionparser/transactionparser_test.go
@@ -8,13 +8,13 @@ import (
 
 	"github.com/iotaledger/hive.go/events"
 
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/payload"
 	"github.com/iotaledger/goshimmer/packages/binary/signature/ed25119"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message/payload/data"
 )
 
 func BenchmarkTransactionParser_ParseBytesSame(b *testing.B) {
-	txBytes := message.New(message.EmptyId, message.EmptyId, ed25119.GenerateKeyPair(), time.Now(), 0, data.New([]byte("Test"))).Bytes()
+	txBytes := message.New(message.EmptyId, message.EmptyId, ed25119.GenerateKeyPair(), time.Now(), 0, payload.NewData([]byte("Test"))).Bytes()
 	txParser := New()
 
 	b.ResetTimer()
@@ -29,7 +29,7 @@ func BenchmarkTransactionParser_ParseBytesSame(b *testing.B) {
 func BenchmarkTransactionParser_ParseBytesDifferent(b *testing.B) {
 	transactionBytes := make([][]byte, b.N)
 	for i := 0; i < b.N; i++ {
-		transactionBytes[i] = message.New(message.EmptyId, message.EmptyId, ed25119.GenerateKeyPair(), time.Now(), 0, data.New([]byte("Test"+strconv.Itoa(i)))).Bytes()
+		transactionBytes[i] = message.New(message.EmptyId, message.EmptyId, ed25119.GenerateKeyPair(), time.Now(), 0, payload.NewData([]byte("Test"+strconv.Itoa(i)))).Bytes()
 	}
 
 	txParser := New()
@@ -44,12 +44,12 @@ func BenchmarkTransactionParser_ParseBytesDifferent(b *testing.B) {
 }
 
 func TestTransactionParser_ParseTransaction(t *testing.T) {
-	tx := message.New(message.EmptyId, message.EmptyId, ed25119.GenerateKeyPair(), time.Now(), 0, data.New([]byte("Test")))
+	tx := message.New(message.EmptyId, message.EmptyId, ed25119.GenerateKeyPair(), time.Now(), 0, payload.NewData([]byte("Test")))
 
 	txParser := New()
 	txParser.Parse(tx.Bytes(), nil)
 
-	txParser.Events.TransactionParsed.Attach(events.NewClosure(func(tx *message.Transaction) {
+	txParser.Events.TransactionParsed.Attach(events.NewClosure(func(tx *message.Message) {
 		fmt.Println("PARSED!!!")
 	}))
 
diff --git a/packages/binary/tangle/transactionrequester/constants.go b/packages/binary/messagelayer/transactionrequester/constants.go
similarity index 100%
rename from packages/binary/tangle/transactionrequester/constants.go
rename to packages/binary/messagelayer/transactionrequester/constants.go
diff --git a/packages/binary/tangle/transactionrequester/events.go b/packages/binary/messagelayer/transactionrequester/events.go
similarity index 100%
rename from packages/binary/tangle/transactionrequester/events.go
rename to packages/binary/messagelayer/transactionrequester/events.go
diff --git a/packages/binary/tangle/transactionrequester/options.go b/packages/binary/messagelayer/transactionrequester/options.go
similarity index 100%
rename from packages/binary/tangle/transactionrequester/options.go
rename to packages/binary/messagelayer/transactionrequester/options.go
diff --git a/packages/binary/tangle/transactionrequester/transactionrequester.go b/packages/binary/messagelayer/transactionrequester/transactionrequester.go
similarity index 96%
rename from packages/binary/tangle/transactionrequester/transactionrequester.go
rename to packages/binary/messagelayer/transactionrequester/transactionrequester.go
index 2016298c..a81993a8 100644
--- a/packages/binary/tangle/transactionrequester/transactionrequester.go
+++ b/packages/binary/messagelayer/transactionrequester/transactionrequester.go
@@ -7,7 +7,7 @@ import (
 	"github.com/iotaledger/hive.go/async"
 	"github.com/iotaledger/hive.go/events"
 
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
 )
 
 type TransactionRequester struct {
diff --git a/packages/binary/spammer/spammer.go b/packages/binary/spammer/spammer.go
index ea0efc5a..d8adc712 100644
--- a/packages/binary/spammer/spammer.go
+++ b/packages/binary/spammer/spammer.go
@@ -6,11 +6,11 @@ import (
 
 	"github.com/iotaledger/hive.go/types"
 
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/payload"
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/tipselector"
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/transactionparser"
 	"github.com/iotaledger/goshimmer/packages/binary/signature/ed25119"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message/payload/data"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/tipselector"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/transactionparser"
 )
 
 type Spammer struct {
@@ -53,7 +53,7 @@ func (spammer *Spammer) run(tps int, processId int64) {
 
 		trunkTransactionId, branchTransactionId := spammer.tipSelector.GetTips()
 		spammer.transactionParser.Parse(
-			message.New(trunkTransactionId, branchTransactionId, spammingIdentity, time.Now(), 0, data.New([]byte("SPAM"))).Bytes(),
+			message.New(trunkTransactionId, branchTransactionId, spammingIdentity, time.Now(), 0, payload.NewData([]byte("SPAM"))).Bytes(),
 			nil,
 		)
 
@@ -83,7 +83,7 @@ func (spammer *Spammer) sendBurst(transactions int, processId int64) {
 			return
 		}
 
-		spamTransaction := message.New(previousTransactionId, previousTransactionId, spammingIdentity, time.Now(), 0, data.New([]byte("SPAM")))
+		spamTransaction := message.New(previousTransactionId, previousTransactionId, spammingIdentity, time.Now(), 0, payload.NewData([]byte("SPAM")))
 		previousTransactionId = spamTransaction.GetId()
 		burstBuffer[i] = spamTransaction.Bytes()
 	}
diff --git a/packages/binary/storageprefix/storageprefix.go b/packages/binary/storageprefix/storageprefix.go
index 0c960b0a..efafc56e 100644
--- a/packages/binary/storageprefix/storageprefix.go
+++ b/packages/binary/storageprefix/storageprefix.go
@@ -3,10 +3,10 @@ package storageprefix
 var (
 	MainNet = []byte{0}
 
-	TangleTransaction         = []byte{1}
-	TangleTransactionMetadata = []byte{2}
-	TangleApprovers           = []byte{3}
-	TangleMissingTransaction  = []byte{4}
+	Layer0Message         = []byte{1}
+	Layer0MessageMetadata = []byte{2}
+	Layer0Approvers       = []byte{3}
+	Layer0MissingMessage  = []byte{4}
 
 	ValueTransferPayload         = []byte{5}
 	ValueTransferPayloadMetadata = []byte{6}
diff --git a/packages/binary/tangle/model/approver/approver.go b/packages/binary/tangle/model/approver/approver.go
deleted file mode 100644
index b6545c6c..00000000
--- a/packages/binary/tangle/model/approver/approver.go
+++ /dev/null
@@ -1,59 +0,0 @@
-package approver
-
-import (
-	"github.com/iotaledger/hive.go/objectstorage"
-
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
-)
-
-type Approver struct {
-	objectstorage.StorableObjectFlags
-
-	storageKey            []byte
-	referencedTransaction message.Id
-	approvingTransaction  message.Id
-}
-
-func New(referencedTransaction message.Id, approvingTransaction message.Id) *Approver {
-	approver := &Approver{
-		storageKey:            make([]byte, message.IdLength+message.IdLength),
-		referencedTransaction: referencedTransaction,
-		approvingTransaction:  approvingTransaction,
-	}
-
-	copy(approver.storageKey[:message.IdLength], referencedTransaction[:])
-	copy(approver.storageKey[message.IdLength:], approvingTransaction[:])
-
-	return approver
-}
-
-func StorableObjectFromKey(id []byte) (result objectstorage.StorableObject, err error) {
-	approver := &Approver{
-		storageKey: make([]byte, message.IdLength+message.IdLength),
-	}
-	copy(approver.referencedTransaction[:], id[:message.IdLength])
-	copy(approver.approvingTransaction[:], id[message.IdLength:])
-	copy(approver.storageKey, id)
-
-	return approver, nil
-}
-
-func (approver *Approver) ObjectStorageKey() []byte {
-	return approver.storageKey
-}
-
-func (approver *Approver) GetApprovingTransactionId() message.Id {
-	return approver.approvingTransaction
-}
-
-func (approver *Approver) Update(other objectstorage.StorableObject) {
-	panic("approvers should never be overwritten and only stored once to optimize IO")
-}
-
-func (approver *Approver) ObjectStorageValue() (result []byte) {
-	return
-}
-
-func (approver *Approver) UnmarshalObjectStorageValue(data []byte) (err error) {
-	return
-}
diff --git a/packages/binary/tangle/model/approver/cached_approver.go b/packages/binary/tangle/model/approver/cached_approver.go
deleted file mode 100644
index 68fe1bcb..00000000
--- a/packages/binary/tangle/model/approver/cached_approver.go
+++ /dev/null
@@ -1,33 +0,0 @@
-package approver
-
-import (
-	"github.com/iotaledger/hive.go/objectstorage"
-)
-
-type CachedApprover struct {
-	objectstorage.CachedObject
-}
-
-func (cachedApprover *CachedApprover) Unwrap() *Approver {
-	if untypedObject := cachedApprover.Get(); untypedObject == nil {
-		return nil
-	} else {
-		if typedObject := untypedObject.(*Approver); typedObject == nil || typedObject.IsDeleted() {
-			return nil
-		} else {
-			return typedObject
-		}
-	}
-}
-
-type CachedApprovers []*CachedApprover
-
-func (cachedApprovers CachedApprovers) Consume(consumer func(approver *Approver)) (consumed bool) {
-	for _, cachedApprover := range cachedApprovers {
-		consumed = cachedApprover.Consume(func(object objectstorage.StorableObject) {
-			consumer(object.(*Approver))
-		}) || consumed
-	}
-
-	return
-}
diff --git a/packages/binary/tangle/model/message/cached_transaction.go b/packages/binary/tangle/model/message/cached_transaction.go
deleted file mode 100644
index 8657ecb8..00000000
--- a/packages/binary/tangle/model/message/cached_transaction.go
+++ /dev/null
@@ -1,31 +0,0 @@
-package message
-
-import (
-	"github.com/iotaledger/hive.go/objectstorage"
-)
-
-type CachedTransaction struct {
-	objectstorage.CachedObject
-}
-
-func (cachedTransaction *CachedTransaction) Retain() *CachedTransaction {
-	return &CachedTransaction{cachedTransaction.CachedObject.Retain()}
-}
-
-func (cachedTransaction *CachedTransaction) Consume(consumer func(transaction *Transaction)) bool {
-	return cachedTransaction.CachedObject.Consume(func(object objectstorage.StorableObject) {
-		consumer(object.(*Transaction))
-	})
-}
-
-func (cachedTransaction *CachedTransaction) Unwrap() *Transaction {
-	if untypedTransaction := cachedTransaction.Get(); untypedTransaction == nil {
-		return nil
-	} else {
-		if typeCastedTransaction := untypedTransaction.(*Transaction); typeCastedTransaction == nil || typeCastedTransaction.IsDeleted() {
-			return nil
-		} else {
-			return typeCastedTransaction
-		}
-	}
-}
diff --git a/packages/binary/tangle/model/message/init.go b/packages/binary/tangle/model/message/init.go
deleted file mode 100644
index 15999765..00000000
--- a/packages/binary/tangle/model/message/init.go
+++ /dev/null
@@ -1,10 +0,0 @@
-package message
-
-import (
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message/payload"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message/payload/data"
-)
-
-func init() {
-	payload.SetGenericUnmarshalerFactory(data.GenericPayloadUnmarshalerFactory)
-}
diff --git a/packages/binary/tangle/model/message/payload/data/init.go b/packages/binary/tangle/model/message/payload/data/init.go
deleted file mode 100644
index f1ae7c9d..00000000
--- a/packages/binary/tangle/model/message/payload/data/init.go
+++ /dev/null
@@ -1,9 +0,0 @@
-package data
-
-import (
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message/payload"
-)
-
-func init() {
-	payload.RegisterType(Type, GenericPayloadUnmarshalerFactory(Type))
-}
diff --git a/packages/binary/tangle/model/missingtransaction/cached_missingtransaction.go b/packages/binary/tangle/model/missingtransaction/cached_missingtransaction.go
deleted file mode 100644
index f50f5321..00000000
--- a/packages/binary/tangle/model/missingtransaction/cached_missingtransaction.go
+++ /dev/null
@@ -1,21 +0,0 @@
-package missingtransaction
-
-import (
-	"github.com/iotaledger/hive.go/objectstorage"
-)
-
-type CachedMissingTransaction struct {
-	objectstorage.CachedObject
-}
-
-func (cachedObject *CachedMissingTransaction) Unwrap() *MissingTransaction {
-	if untypedObject := cachedObject.Get(); untypedObject == nil {
-		return nil
-	} else {
-		if typedObject := untypedObject.(*MissingTransaction); typedObject == nil || typedObject.IsDeleted() {
-			return nil
-		} else {
-			return typedObject
-		}
-	}
-}
diff --git a/packages/binary/tangle/model/missingtransaction/missingtransaction.go b/packages/binary/tangle/model/missingtransaction/missingtransaction.go
deleted file mode 100644
index a4fc5871..00000000
--- a/packages/binary/tangle/model/missingtransaction/missingtransaction.go
+++ /dev/null
@@ -1,58 +0,0 @@
-package missingtransaction
-
-import (
-	"time"
-
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
-	"github.com/iotaledger/hive.go/objectstorage"
-)
-
-type MissingTransaction struct {
-	objectstorage.StorableObjectFlags
-
-	transactionId message.Id
-	missingSince  time.Time
-}
-
-func New(transactionId message.Id) *MissingTransaction {
-	return &MissingTransaction{
-		transactionId: transactionId,
-		missingSince:  time.Now(),
-	}
-}
-
-func StorableObjectFromKey(key []byte) (objectstorage.StorableObject, error) {
-	result := &MissingTransaction{}
-	copy(result.transactionId[:], key)
-
-	return result, nil
-}
-
-func (missingTransaction *MissingTransaction) GetTransactionId() message.Id {
-	return missingTransaction.transactionId
-}
-
-func (missingTransaction *MissingTransaction) GetMissingSince() time.Time {
-	return missingTransaction.missingSince
-}
-
-func (missingTransaction *MissingTransaction) Update(other objectstorage.StorableObject) {
-	panic("missing transactions should never be overwritten and only stored once to optimize IO")
-}
-
-func (missingTransaction *MissingTransaction) ObjectStorageKey() []byte {
-	return missingTransaction.transactionId[:]
-}
-
-func (missingTransaction *MissingTransaction) ObjectStorageValue() (result []byte) {
-	result, err := missingTransaction.missingSince.MarshalBinary()
-	if err != nil {
-		panic(err)
-	}
-
-	return
-}
-
-func (missingTransaction *MissingTransaction) UnmarshalObjectStorageValue(data []byte) (err error) {
-	return missingTransaction.missingSince.UnmarshalBinary(data)
-}
diff --git a/packages/binary/tangle/model/transactionmetadata/cached_transactionmetadata.go b/packages/binary/tangle/model/transactionmetadata/cached_transactionmetadata.go
deleted file mode 100644
index c8db28e1..00000000
--- a/packages/binary/tangle/model/transactionmetadata/cached_transactionmetadata.go
+++ /dev/null
@@ -1,25 +0,0 @@
-package transactionmetadata
-
-import (
-	"github.com/iotaledger/hive.go/objectstorage"
-)
-
-type CachedTransactionMetadata struct {
-	objectstorage.CachedObject
-}
-
-func (cachedObject *CachedTransactionMetadata) Retain() *CachedTransactionMetadata {
-	return &CachedTransactionMetadata{cachedObject.CachedObject.Retain()}
-}
-
-func (cachedObject *CachedTransactionMetadata) Unwrap() *TransactionMetadata {
-	if untypedObject := cachedObject.Get(); untypedObject == nil {
-		return nil
-	} else {
-		if typedObject := untypedObject.(*TransactionMetadata); typedObject == nil || typedObject.IsDeleted() {
-			return nil
-		} else {
-			return typedObject
-		}
-	}
-}
diff --git a/packages/binary/tangle/model/transactionmetadata/proto.go b/packages/binary/tangle/model/transactionmetadata/proto.go
deleted file mode 100644
index 652cb7d4..00000000
--- a/packages/binary/tangle/model/transactionmetadata/proto.go
+++ /dev/null
@@ -1,51 +0,0 @@
-package transactionmetadata
-
-import (
-	"fmt"
-	"reflect"
-	"runtime"
-	"time"
-	"unsafe"
-)
-
-type Proto struct {
-	receivedTime       time.Time
-	solidificationTime time.Time
-	solid              bool
-}
-
-// region GENERIC SERIALIZATION CODE ///////////////////////////////////////////////////////////////////////////////////
-
-var sizeOfProto = int(unsafe.Sizeof(Proto{}))
-
-func ProtoFromBytes(bytes []byte) (result *Proto, err error) {
-	if bytesLength := len(bytes); bytesLength != sizeOfProto {
-		return nil, fmt.Errorf("bytes are not long enough (%d instead of %d)", bytesLength, sizeOfProto)
-	}
-
-	copiedBytes := make([]byte, sizeOfProto)
-	copy(copiedBytes, bytes)
-
-	result = (*Proto)(unsafe.Pointer(
-		(*reflect.SliceHeader)(unsafe.Pointer(&copiedBytes)).Data,
-	))
-
-	runtime.KeepAlive(copiedBytes)
-
-	return
-}
-
-func (proto *Proto) ToBytes() (result []byte) {
-	result = make([]byte, sizeOfProto)
-	copy(result, *(*[]byte)(unsafe.Pointer(&reflect.SliceHeader{
-		Data: uintptr(unsafe.Pointer(proto)),
-		Len:  sizeOfProto,
-		Cap:  sizeOfProto,
-	})))
-
-	runtime.KeepAlive(proto)
-
-	return
-}
-
-// endregion ///////////////////////////////////////////////////////////////////////////////////////////////////////////
diff --git a/packages/binary/tangle/model/transactionmetadata/transactionmetadata.go b/packages/binary/tangle/model/transactionmetadata/transactionmetadata.go
deleted file mode 100644
index 74e222bb..00000000
--- a/packages/binary/tangle/model/transactionmetadata/transactionmetadata.go
+++ /dev/null
@@ -1,109 +0,0 @@
-package transactionmetadata
-
-import (
-	"sync"
-	"time"
-
-	"github.com/iotaledger/hive.go/objectstorage"
-
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
-)
-
-type TransactionMetadata struct {
-	objectstorage.StorableObjectFlags
-
-	transactionId      message.Id
-	receivedTime       time.Time
-	solid              bool
-	solidificationTime time.Time
-
-	solidMutex              sync.RWMutex
-	solidificationTimeMutex sync.RWMutex
-}
-
-func New(transactionId message.Id) *TransactionMetadata {
-	return &TransactionMetadata{
-		transactionId: transactionId,
-		receivedTime:  time.Now(),
-	}
-}
-
-func StorableObjectFromKey(id []byte) (objectstorage.StorableObject, error) {
-	result := &TransactionMetadata{}
-	copy(result.transactionId[:], id)
-
-	return result, nil
-}
-
-func (transactionMetadata *TransactionMetadata) IsSolid() (result bool) {
-	transactionMetadata.solidMutex.RLock()
-	result = transactionMetadata.solid
-	transactionMetadata.solidMutex.RUnlock()
-
-	return
-}
-
-func (transactionMetadata *TransactionMetadata) SetSolid(solid bool) (modified bool) {
-	transactionMetadata.solidMutex.RLock()
-	if transactionMetadata.solid != solid {
-		transactionMetadata.solidMutex.RUnlock()
-
-		transactionMetadata.solidMutex.Lock()
-		if transactionMetadata.solid != solid {
-			transactionMetadata.solid = solid
-			if solid {
-				transactionMetadata.solidificationTimeMutex.Lock()
-				transactionMetadata.solidificationTime = time.Now()
-				transactionMetadata.solidificationTimeMutex.Unlock()
-			}
-
-			transactionMetadata.SetModified()
-
-			modified = true
-		}
-		transactionMetadata.solidMutex.Unlock()
-
-	} else {
-		transactionMetadata.solidMutex.RUnlock()
-	}
-
-	return
-}
-
-func (transactionMetadata *TransactionMetadata) GetSoldificationTime() time.Time {
-	transactionMetadata.solidificationTimeMutex.RLock()
-	defer transactionMetadata.solidificationTimeMutex.RUnlock()
-
-	return transactionMetadata.solidificationTime
-}
-
-func (transactionMetadata *TransactionMetadata) ObjectStorageKey() []byte {
-	return transactionMetadata.transactionId[:]
-}
-
-func (transactionMetadata *TransactionMetadata) Update(other objectstorage.StorableObject) {
-
-}
-
-func (transactionMetadata *TransactionMetadata) ObjectStorageValue() []byte {
-	return (&Proto{
-		receivedTime:       transactionMetadata.receivedTime,
-		solidificationTime: transactionMetadata.solidificationTime,
-		solid:              transactionMetadata.solid,
-	}).ToBytes()
-}
-
-func (transactionMetadata *TransactionMetadata) UnmarshalObjectStorageValue(data []byte) (err error) {
-	proto, err := ProtoFromBytes(data)
-	if err != nil {
-		return
-	}
-
-	transactionMetadata.receivedTime = proto.receivedTime
-	transactionMetadata.solidificationTime = proto.solidificationTime
-	transactionMetadata.solid = proto.solid
-
-	return
-}
-
-var _ objectstorage.StorableObject = &TransactionMetadata{}
diff --git a/packages/binary/tangle/transactionparser/transaction_filter.go b/packages/binary/tangle/transactionparser/transaction_filter.go
deleted file mode 100644
index c13d94ec..00000000
--- a/packages/binary/tangle/transactionparser/transaction_filter.go
+++ /dev/null
@@ -1,14 +0,0 @@
-package transactionparser
-
-import (
-	"github.com/iotaledger/hive.go/autopeering/peer"
-
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
-)
-
-type TransactionFilter interface {
-	Filter(tx *message.Transaction, peer *peer.Peer)
-	OnAccept(callback func(tx *message.Transaction, peer *peer.Peer))
-	OnReject(callback func(tx *message.Transaction, err error, peer *peer.Peer))
-	Shutdown()
-}
diff --git a/packages/binary/valuetransfer/payload/payload.go b/packages/binary/valuetransfer/payload/payload.go
index c9e6ff69..d41e1439 100644
--- a/packages/binary/valuetransfer/payload/payload.go
+++ b/packages/binary/valuetransfer/payload/payload.go
@@ -8,22 +8,21 @@ import (
 	"github.com/iotaledger/hive.go/stringify"
 	"golang.org/x/crypto/blake2b"
 
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message/payload"
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/payload"
 	"github.com/iotaledger/goshimmer/packages/binary/valuetransfer/transaction"
 )
 
 type Payload struct {
 	objectstorage.StorableObjectFlags
 
-	trunkPayloadId  Id
-	branchPayloadId Id
-	transaction     *transaction.Transaction
-
 	id      *Id
 	idMutex sync.RWMutex
 
-	bytes      []byte
-	bytesMutex sync.RWMutex
+	trunkPayloadId  Id
+	branchPayloadId Id
+	transaction     *transaction.Transaction
+	bytes           []byte
+	bytesMutex      sync.RWMutex
 }
 
 func New(trunkPayloadId, branchPayloadId Id, valueTransfer *transaction.Transaction) *Payload {
@@ -34,20 +33,34 @@ func New(trunkPayloadId, branchPayloadId Id, valueTransfer *transaction.Transact
 	}
 }
 
-func StorableObjectFromKey(key []byte) (objectstorage.StorableObject, error) {
-	id, err, _ := IdFromBytes(key)
-	if err != nil {
-		return nil, err
+// FromBytes parses the marshaled version of a Payload into an object.
+// It either returns a new Payload or fills an optionally provided Payload with the parsed information.
+func FromBytes(bytes []byte, optionalTargetObject ...*Payload) (result *Payload, err error, consumedBytes int) {
+	marshalUtil := marshalutil.New(bytes)
+	result, err = Parse(marshalUtil, optionalTargetObject...)
+	consumedBytes = marshalUtil.ReadOffset()
+
+	return
+}
+
+func StorableObjectFromKey(key []byte) (result objectstorage.StorableObject, err error, consumedBytes int) {
+	result = &Payload{}
+
+	// parse the properties that are stored in the key
+	marshalUtil := marshalutil.New(key)
+	if payloadId, idErr := ParseId(marshalUtil); idErr != nil {
+		err = idErr
+
+		return
+	} else {
+		result.(*Payload).id = &payloadId
 	}
+	consumedBytes = marshalUtil.ReadOffset()
 
-	return &Payload{
-		id: &id,
-	}, nil
+	return
 }
 
-// FromBytes parses the marshaled version of a Payload into an object.
-// It either returns a new Payload or fills an optionally provided Payload with the parsed information.
-func FromBytes(bytes []byte, optionalTargetObject ...*Payload) (result *Payload, err error, consumedBytes int) {
+func Parse(marshalUtil *marshalutil.MarshalUtil, optionalTargetObject ...*Payload) (result *Payload, err error) {
 	// determine the target object that will hold the unmarshaled information
 	switch len(optionalTargetObject) {
 	case 0:
@@ -55,49 +68,17 @@ func FromBytes(bytes []byte, optionalTargetObject ...*Payload) (result *Payload,
 	case 1:
 		result = optionalTargetObject[0]
 	default:
-		panic("too many arguments in call to OutputFromBytes")
+		panic("too many arguments in call to Parse")
 	}
 
-	// initialize helper
-	marshalUtil := marshalutil.New(bytes)
+	if _, err = marshalUtil.Parse(func(data []byte) (parseResult interface{}, parseErr error, parsedBytes int) {
+		parseErr, parsedBytes = result.UnmarshalObjectStorageValue(data)
 
-	// read information that are required to identify the payload from the outside
-	_, err = marshalUtil.ReadUint32()
-	if err != nil {
 		return
-	}
-	_, err = marshalUtil.ReadUint32()
-	if err != nil {
+	}); err != nil {
 		return
 	}
 
-	// parse trunk payload id
-	parsedTrunkPayloadId, err := marshalUtil.Parse(func(data []byte) (interface{}, error, int) { return IdFromBytes(data) })
-	if err != nil {
-		return
-	}
-	result.trunkPayloadId = parsedTrunkPayloadId.(Id)
-
-	// parse branch payload id
-	parsedBranchPayloadId, err := marshalUtil.Parse(func(data []byte) (interface{}, error, int) { return IdFromBytes(data) })
-	if err != nil {
-		return
-	}
-	result.branchPayloadId = parsedBranchPayloadId.(Id)
-
-	// parse transfer
-	parsedTransfer, err := marshalUtil.Parse(func(data []byte) (interface{}, error, int) { return transaction.FromBytes(data) })
-	if err != nil {
-		return
-	}
-	result.transaction = parsedTransfer.(*transaction.Transaction)
-
-	// return the number of bytes we processed
-	consumedBytes = marshalUtil.ReadOffset()
-
-	// store bytes, so we don't have to marshal manually
-	result.bytes = bytes[:consumedBytes]
-
 	return
 }
 
@@ -207,22 +188,49 @@ func (payload *Payload) ObjectStorageValue() []byte {
 	return payload.Bytes()
 }
 
-func (payload *Payload) UnmarshalObjectStorageValue(data []byte) (err error) {
-	_, err, _ = FromBytes(data, payload)
+func (payload *Payload) UnmarshalObjectStorageValue(data []byte) (err error, consumedBytes int) {
+	marshalUtil := marshalutil.New(data)
+
+	// read information that are required to identify the payload from the outside
+	_, err = marshalUtil.ReadUint32()
+	if err != nil {
+		return
+	}
+	_, err = marshalUtil.ReadUint32()
+	if err != nil {
+		return
+	}
+
+	// parse trunk payload id
+	if payload.trunkPayloadId, err = ParseId(marshalUtil); err != nil {
+		return
+	}
+	if payload.branchPayloadId, err = ParseId(marshalUtil); err != nil {
+		return
+	}
+	if payload.transaction, err = transaction.Parse(marshalUtil); err != nil {
+		return
+	}
+
+	// return the number of bytes we processed
+	consumedBytes = marshalUtil.ReadOffset()
+
+	// store bytes, so we don't have to marshal manually
+	payload.bytes = make([]byte, consumedBytes)
+	copy(payload.bytes, data[:consumedBytes])
 
 	return
 }
 
 func (payload *Payload) Unmarshal(data []byte) (err error) {
-	_, err, _ = FromBytes(data, payload)
+	_, err, _ = FromBytes(data)
 
 	return
 }
 
 func init() {
 	payload.RegisterType(Type, func(data []byte) (payload payload.Payload, err error) {
-		payload = &Payload{}
-		err = payload.Unmarshal(data)
+		payload, err, _ = FromBytes(data)
 
 		return
 	})
diff --git a/packages/binary/valuetransfer/payload/payload_test.go b/packages/binary/valuetransfer/payload/payload_test.go
index 0dc21937..fc7b762a 100644
--- a/packages/binary/valuetransfer/payload/payload_test.go
+++ b/packages/binary/valuetransfer/payload/payload_test.go
@@ -7,8 +7,8 @@ import (
 
 	"github.com/stretchr/testify/assert"
 
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
 	"github.com/iotaledger/goshimmer/packages/binary/signature/ed25119"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
 	"github.com/iotaledger/goshimmer/packages/binary/valuetransfer/address"
 	"github.com/iotaledger/goshimmer/packages/binary/valuetransfer/address/signaturescheme"
 	"github.com/iotaledger/goshimmer/packages/binary/valuetransfer/balance"
diff --git a/packages/binary/valuetransfer/tangle/attachment.go b/packages/binary/valuetransfer/tangle/attachment.go
index 372d91eb..c7dcd552 100644
--- a/packages/binary/valuetransfer/tangle/attachment.go
+++ b/packages/binary/valuetransfer/tangle/attachment.go
@@ -71,13 +71,13 @@ func ParseAttachment(marshalUtil *marshalutil.MarshalUtil) (*Attachment, error)
 
 // AttachmentFromStorageKey gets called when we restore an Attachment from the storage - it parses the key bytes and
 // returns the new object.
-func AttachmentFromStorageKey(keyBytes []byte) (objectstorage.StorableObject, error) {
+func AttachmentFromStorageKey(keyBytes []byte) (objectstorage.StorableObject, error, int) {
 	result, err, _ := AttachmentFromBytes(keyBytes)
 	if err != nil {
-		return nil, err
+		return nil, err, 0
 	}
 
-	return result, nil
+	return result, nil, 0
 }
 
 // TransactionId returns the transaction id of this Attachment.
@@ -116,7 +116,7 @@ func (attachment *Attachment) ObjectStorageValue() (data []byte) {
 
 // UnmarshalObjectStorageValue unmarshals the "content part" of an Attachment from a sequence of bytes. Since all of the information
 // for this object are stored in its key, this method does nothing and is only required to conform with the interface.
-func (attachment *Attachment) UnmarshalObjectStorageValue(data []byte) (err error) {
+func (attachment *Attachment) UnmarshalObjectStorageValue(data []byte) (err error, consumedBytes int) {
 	return
 }
 
diff --git a/packages/binary/valuetransfer/tangle/consumer.go b/packages/binary/valuetransfer/tangle/consumer.go
index e0a41212..9dadca65 100644
--- a/packages/binary/valuetransfer/tangle/consumer.go
+++ b/packages/binary/valuetransfer/tangle/consumer.go
@@ -115,7 +115,7 @@ func (consumer *Consumer) ObjectStorageValue() (data []byte) {
 
 // UnmarshalObjectStorageValue unmarshals the "content part" of a Consumer from a sequence of bytes. Since all of the information
 // for this object are stored in its key, this method does nothing and is only required to conform with the interface.
-func (consumer *Consumer) UnmarshalObjectStorageValue(data []byte) (err error) {
+func (consumer *Consumer) UnmarshalObjectStorageValue(data []byte) (err error, consumedBytes int) {
 	return
 }
 
diff --git a/packages/binary/valuetransfer/tangle/missingoutput.go b/packages/binary/valuetransfer/tangle/missingoutput.go
index 628d4a68..6e5e05d5 100644
--- a/packages/binary/valuetransfer/tangle/missingoutput.go
+++ b/packages/binary/valuetransfer/tangle/missingoutput.go
@@ -53,7 +53,7 @@ func MissingOutputFromBytes(bytes []byte, optionalTargetObject ...*MissingOutput
 
 // MissingOutputFromStorageKey gets called when we restore a MissingOutput from the storage. The content will be
 // unmarshaled by an external caller using the binary.ObjectStorageValue interface.
-func MissingOutputFromStorageKey(keyBytes []byte) (objectstorage.StorableObject, error) {
+func MissingOutputFromStorageKey(keyBytes []byte) (objectstorage.StorableObject, error, int) {
 	outputId, err, _ := transaction.OutputIdFromBytes(keyBytes)
 	if err != nil {
 		panic(err)
@@ -61,7 +61,7 @@ func MissingOutputFromStorageKey(keyBytes []byte) (objectstorage.StorableObject,
 
 	return &MissingOutput{
 		outputId: outputId,
-	}, nil
+	}, nil, transaction.OutputIdLength
 }
 
 // Id returns the id of the Output that is missing.
@@ -97,8 +97,8 @@ func (missingOutput *MissingOutput) ObjectStorageValue() []byte {
 
 // UnmarshalObjectStorageValue restores the values of a MissingOutput from a sequence of bytes using the  encoding.BinaryUnmarshaler
 // interface.
-func (missingOutput *MissingOutput) UnmarshalObjectStorageValue(data []byte) (err error) {
-	_, err, _ = MissingOutputFromBytes(data, missingOutput)
+func (missingOutput *MissingOutput) UnmarshalObjectStorageValue(data []byte) (err error, consumedBytes int) {
+	_, err, consumedBytes = MissingOutputFromBytes(data, missingOutput)
 
 	return
 }
diff --git a/packages/binary/valuetransfer/tangle/missingpayload.go b/packages/binary/valuetransfer/tangle/missingpayload.go
index 52714753..395365a2 100644
--- a/packages/binary/valuetransfer/tangle/missingpayload.go
+++ b/packages/binary/valuetransfer/tangle/missingpayload.go
@@ -54,8 +54,8 @@ func MissingPayloadFromBytes(bytes []byte, optionalTargetObject ...*MissingPaylo
 
 // MissingPayloadFromStorageKey gets called when we restore an entry for a missing value transfer payload from the storage. The bytes and
 // the content will be unmarshaled by an external caller using the binary.ObjectStorageValue interface.
-func MissingPayloadFromStorageKey([]byte) (objectstorage.StorableObject, error) {
-	return &MissingPayload{}, nil
+func MissingPayloadFromStorageKey([]byte) (result objectstorage.StorableObject, err error, consumedBytes int) {
+	return
 }
 
 // GetId returns the payload id, that is missing.
@@ -96,8 +96,8 @@ func (missingPayload *MissingPayload) ObjectStorageValue() (data []byte) {
 }
 
 // UnmarshalObjectStorageValue is required to match the encoding.BinaryUnmarshaler interface.
-func (missingPayload *MissingPayload) UnmarshalObjectStorageValue(data []byte) (err error) {
-	_, err, _ = MissingPayloadFromBytes(data, missingPayload)
+func (missingPayload *MissingPayload) UnmarshalObjectStorageValue(data []byte) (err error, consumedBytes int) {
+	_, err, consumedBytes = MissingPayloadFromBytes(data, missingPayload)
 
 	return
 }
diff --git a/packages/binary/valuetransfer/tangle/payloadapprover.go b/packages/binary/valuetransfer/tangle/payloadapprover.go
index f0b34f1d..4664cb16 100644
--- a/packages/binary/valuetransfer/tangle/payloadapprover.go
+++ b/packages/binary/valuetransfer/tangle/payloadapprover.go
@@ -34,25 +34,27 @@ func NewPayloadApprover(referencedPayload payload.Id, approvingPayload payload.I
 // PayloadApproverFromStorageKey get's called when we restore transaction metadata from the storage.
 // In contrast to other database models, it unmarshals the information from the key and does not use the UnmarshalObjectStorageValue
 // method.
-func PayloadApproverFromStorageKey(idBytes []byte) (objectstorage.StorableObject, error) {
+func PayloadApproverFromStorageKey(idBytes []byte) (result objectstorage.StorableObject, err error, consumedBytes int) {
 	marshalUtil := marshalutil.New(idBytes)
 
 	referencedPayloadId, err := payload.ParseId(marshalUtil)
 	if err != nil {
-		return nil, err
+		return
 	}
 	approvingPayloadId, err := payload.ParseId(marshalUtil)
 	if err != nil {
-		return nil, err
+		return
 	}
 
-	result := &PayloadApprover{
+	result = &PayloadApprover{
 		referencedPayloadId: referencedPayloadId,
 		approvingPayloadId:  approvingPayloadId,
 		storageKey:          marshalUtil.Bytes(true),
 	}
 
-	return result, nil
+	consumedBytes = marshalUtil.ReadOffset()
+
+	return
 }
 
 // GetApprovingPayloadId returns the id of the approving payload.
@@ -74,8 +76,8 @@ func (payloadApprover *PayloadApprover) ObjectStorageValue() (data []byte) {
 
 // UnmarshalObjectStorageValue is implemented to conform with the StorableObject interface, but it does not really do
 // anything, since all of the information about an approver are stored in the "key".
-func (payloadApprover *PayloadApprover) UnmarshalObjectStorageValue(data []byte) error {
-	return nil
+func (payloadApprover *PayloadApprover) UnmarshalObjectStorageValue(data []byte) (err error, consumedBytes int) {
+	return
 }
 
 // Update is disabled and panics if it ever gets called - updates are supposed to happen through the setters.
diff --git a/packages/binary/valuetransfer/tangle/payloadmetadata.go b/packages/binary/valuetransfer/tangle/payloadmetadata.go
index a73dec84..4308e595 100644
--- a/packages/binary/valuetransfer/tangle/payloadmetadata.go
+++ b/packages/binary/valuetransfer/tangle/payloadmetadata.go
@@ -62,15 +62,16 @@ func PayloadMetadataFromBytes(bytes []byte, optionalTargetObject ...*PayloadMeta
 
 // PayloadMetadataFromStorageKey gets called when we restore transaction metadata from the storage. The bytes and the content will be
 // unmarshaled by an external caller using the binary.ObjectStorageValue interface.
-func PayloadMetadataFromStorageKey(id []byte) (objectstorage.StorableObject, error) {
-	result := &PayloadMetadata{}
+func PayloadMetadataFromStorageKey(id []byte) (result objectstorage.StorableObject, err error, consumedBytes int) {
+	result = &PayloadMetadata{}
 
-	var err error
-	if result.payloadId, err = payload.ParseId(marshalutil.New(id)); err != nil {
-		return nil, err
+	marshalUtil := marshalutil.New(id)
+	if result.(*PayloadMetadata).payloadId, err = payload.ParseId(marshalUtil); err != nil {
+		return
 	}
+	consumedBytes = marshalUtil.ReadOffset()
 
-	return result, nil
+	return
 }
 
 // ParsePayloadMetadata is a wrapper for simplified unmarshaling in a byte stream using the marshalUtil package.
@@ -125,7 +126,7 @@ func (payloadMetadata *PayloadMetadata) SetSolid(solid bool) (modified bool) {
 	return
 }
 
-// GetSoldificationTime returns the time when the payload was marked to be solid.
+// SoldificationTime returns the time when the payload was marked to be solid.
 func (payloadMetadata *PayloadMetadata) GetSoldificationTime() time.Time {
 	payloadMetadata.solidificationTimeMutex.RLock()
 	defer payloadMetadata.solidificationTimeMutex.RUnlock()
@@ -171,8 +172,8 @@ func (payloadMetadata *PayloadMetadata) ObjectStorageValue() []byte {
 }
 
 // UnmarshalObjectStorageValue is required to match the encoding.BinaryUnmarshaler interface.
-func (payloadMetadata *PayloadMetadata) UnmarshalObjectStorageValue(data []byte) (err error) {
-	_, err, _ = PayloadMetadataFromBytes(data, payloadMetadata)
+func (payloadMetadata *PayloadMetadata) UnmarshalObjectStorageValue(data []byte) (err error, consumedBytes int) {
+	_, err, consumedBytes = PayloadMetadataFromBytes(data, payloadMetadata)
 
 	return
 }
diff --git a/packages/binary/valuetransfer/tangle/tangle.go b/packages/binary/valuetransfer/tangle/tangle.go
index bea66a48..01b00b50 100644
--- a/packages/binary/valuetransfer/tangle/tangle.go
+++ b/packages/binary/valuetransfer/tangle/tangle.go
@@ -46,7 +46,7 @@ func New(badgerInstance *badger.DB, storageId []byte) (result *Tangle) {
 		approverStorage:        objectstorage.New(badgerInstance, append(storageId, storageprefix.ValueTransferApprover...), PayloadApproverFromStorageKey, objectstorage.CacheTime(time.Second), objectstorage.PartitionKey(payload.IdLength, payload.IdLength), objectstorage.KeysOnly(true)),
 
 		// transaction related storage
-		transactionOutputMetadataStorage: objectstorage.New(badgerInstance, append(storageId, storageprefix.TangleApprovers...), transaction.OutputFromStorageKey, objectstorage.CacheTime(time.Second)),
+		transactionOutputMetadataStorage: objectstorage.New(badgerInstance, append(storageId, storageprefix.Layer0Approvers...), transaction.OutputFromStorageKey, objectstorage.CacheTime(time.Second)),
 		missingOutputStorage:             objectstorage.New(badgerInstance, append(storageId, storageprefix.ValueTransferMissingPayload...), MissingOutputFromStorageKey, objectstorage.CacheTime(time.Second)),
 		consumerStorage:                  objectstorage.New(badgerInstance, append(storageId, storageprefix.ValueTransferConsumer...), transaction.OutputFromStorageKey, objectstorage.CacheTime(time.Second)),
 
diff --git a/packages/binary/valuetransfer/tangle/transactionmetadata.go b/packages/binary/valuetransfer/tangle/transactionmetadata.go
index a920bce1..98a36a74 100644
--- a/packages/binary/valuetransfer/tangle/transactionmetadata.go
+++ b/packages/binary/valuetransfer/tangle/transactionmetadata.go
@@ -171,8 +171,8 @@ func (transactionMetadata *TransactionMetadata) ObjectStorageValue() []byte {
 
 // UnmarshalObjectStorageValue restores the values of a TransactionMetadata object from a sequence of bytes and matches the
 // encoding.BinaryUnmarshaler interface.
-func (transactionMetadata *TransactionMetadata) UnmarshalObjectStorageValue(data []byte) (err error) {
-	_, err, _ = TransactionMetadataFromBytes(data, transactionMetadata)
+func (transactionMetadata *TransactionMetadata) UnmarshalObjectStorageValue(data []byte) (err error, consumedBytes int) {
+	_, err, consumedBytes = TransactionMetadataFromBytes(data, transactionMetadata)
 
 	return
 }
diff --git a/packages/binary/valuetransfer/tangle/transactionoutputmetadata.go b/packages/binary/valuetransfer/tangle/transactionoutputmetadata.go
index 75ebbb5a..a4c7e976 100644
--- a/packages/binary/valuetransfer/tangle/transactionoutputmetadata.go
+++ b/packages/binary/valuetransfer/tangle/transactionoutputmetadata.go
@@ -165,8 +165,8 @@ func (transactionOutputMetadata *TransactionOutputMetadata) ObjectStorageValue()
 
 // UnmarshalObjectStorageValue restores the values of a TransactionOutputMetadata object from a sequence of bytes and matches the
 // encoding.BinaryUnmarshaler interface.
-func (transactionOutputMetadata *TransactionOutputMetadata) UnmarshalObjectStorageValue(data []byte) (err error) {
-	_, err, _ = TransactionOutputMetadataFromBytes(data, transactionOutputMetadata)
+func (transactionOutputMetadata *TransactionOutputMetadata) UnmarshalObjectStorageValue(data []byte) (err error, consumedBytes int) {
+	_, err, consumedBytes = TransactionOutputMetadataFromBytes(data, transactionOutputMetadata)
 
 	return
 }
diff --git a/packages/binary/valuetransfer/transaction/output.go b/packages/binary/valuetransfer/transaction/output.go
index 270e73fc..a5d0aab1 100644
--- a/packages/binary/valuetransfer/transaction/output.go
+++ b/packages/binary/valuetransfer/transaction/output.go
@@ -83,10 +83,10 @@ func OutputFromBytes(bytes []byte, optionalTargetObject ...*Output) (result *Out
 // OutputFromStorageKey get's called when we restore a Output from the storage.
 // In contrast to other database models, it unmarshals some information from the key so we simply store the key before
 // it gets handed over to UnmarshalObjectStorageValue (by the ObjectStorage).
-func OutputFromStorageKey(keyBytes []byte) (objectstorage.StorableObject, error) {
+func OutputFromStorageKey(keyBytes []byte) (result objectstorage.StorableObject, err error, consumedBytes int) {
 	return &Output{
 		storageKey: keyBytes[:OutputIdLength],
-	}, nil
+	}, nil, OutputIdLength
 }
 
 // Address returns the address that this output belongs to.
@@ -120,7 +120,7 @@ func (output *Output) ObjectStorageValue() (data []byte) {
 	balanceCount := len(output.balances)
 
 	// initialize helper
-	marshalUtil := marshalutil.New(4 + balanceCount*balance.Length)
+	marshalUtil := marshalutil.New(marshalutil.BOOL_SIZE + marshalutil.TIME_SIZE + marshalutil.UINT32_SIZE + balanceCount*balance.Length)
 	marshalUtil.WriteBool(output.solid)
 	marshalUtil.WriteTime(output.solidSince)
 	marshalUtil.WriteUint32(uint32(balanceCount))
@@ -133,8 +133,8 @@ func (output *Output) ObjectStorageValue() (data []byte) {
 
 // UnmarshalObjectStorageValue restores a Output from a serialized version in the ObjectStorage with parts of the object
 // being stored in its key rather than the content of the database to reduce storage requirements.
-func (output *Output) UnmarshalObjectStorageValue(data []byte) (err error) {
-	_, err, _ = OutputFromBytes(marshalutil.New(output.storageKey).WriteBytes(data).Bytes(), output)
+func (output *Output) UnmarshalObjectStorageValue(data []byte) (err error, consumedBytes int) {
+	_, err, consumedBytes = OutputFromBytes(marshalutil.New(output.storageKey).WriteBytes(data).Bytes(), output)
 
 	return
 }
diff --git a/packages/binary/valuetransfer/transaction/transaction.go b/packages/binary/valuetransfer/transaction/transaction.go
index 20e1c2a4..0d685c60 100644
--- a/packages/binary/valuetransfer/transaction/transaction.go
+++ b/packages/binary/valuetransfer/transaction/transaction.go
@@ -45,6 +45,14 @@ func New(inputs *Inputs, outputs *Outputs) *Transaction {
 }
 
 func FromBytes(bytes []byte, optionalTargetObject ...*Transaction) (result *Transaction, err error, consumedBytes int) {
+	marshalUtil := marshalutil.New(bytes)
+	result, err = Parse(marshalUtil, optionalTargetObject...)
+	consumedBytes = marshalUtil.ReadOffset()
+
+	return
+}
+
+func FromStorageKey(key []byte, optionalTargetObject ...*Transaction) (result objectstorage.StorableObject, err error, consumedBytes int) {
 	// determine the target object that will hold the unmarshaled information
 	switch len(optionalTargetObject) {
 	case 0:
@@ -52,63 +60,41 @@ func FromBytes(bytes []byte, optionalTargetObject ...*Transaction) (result *Tran
 	case 1:
 		result = optionalTargetObject[0]
 	default:
-		panic("too many arguments in call to OutputFromBytes")
+		panic("too many arguments in call to FromStorageKey")
 	}
 
-	// initialize helper
-	marshalUtil := marshalutil.New(bytes)
-
-	// unmarshal inputs
-	parsedInputs, err := marshalUtil.Parse(func(data []byte) (interface{}, error, int) { return InputsFromBytes(data) })
+	marshalUtil := marshalutil.New(key)
+	id, err := ParseId(marshalUtil)
 	if err != nil {
 		return
 	}
-	result.inputs = parsedInputs.(*Inputs)
+	result.(*Transaction).id = &id
 
-	// unmarshal outputs
-	parsedOutputs, err := marshalUtil.Parse(func(data []byte) (interface{}, error, int) { return OutputsFromBytes(data) })
-	if err != nil {
-		return
+	return
+}
+
+func Parse(marshalUtil *marshalutil.MarshalUtil, optionalTargetObject ...*Transaction) (result *Transaction, err error) {
+	// determine the target object that will hold the unmarshaled information
+	switch len(optionalTargetObject) {
+	case 0:
+		result = &Transaction{}
+	case 1:
+		result = optionalTargetObject[0]
+	default:
+		panic("too many arguments in call to Parse")
 	}
-	result.outputs = parsedOutputs.(*Outputs)
 
-	// store essence bytes
-	essenceBytesCount := marshalUtil.ReadOffset()
-	result.essenceBytes = make([]byte, essenceBytesCount)
-	copy(result.essenceBytes, bytes[:essenceBytesCount])
+	if _, err = marshalUtil.Parse(func(data []byte) (parseResult interface{}, parseErr error, parsedBytes int) {
+		parseErr, parsedBytes = result.UnmarshalObjectStorageValue(data)
 
-	// unmarshal outputs
-	parsedSignatures, err := marshalUtil.Parse(func(data []byte) (interface{}, error, int) { return SignaturesFromBytes(data) })
-	if err != nil {
+		return
+	}); err != nil {
 		return
 	}
-	result.signatures = parsedSignatures.(*Signatures)
-
-	// store signature bytes
-	signatureBytesCount := marshalUtil.ReadOffset() - essenceBytesCount
-	result.signatureBytes = make([]byte, signatureBytesCount)
-	copy(result.signatureBytes, bytes[essenceBytesCount:essenceBytesCount+signatureBytesCount])
-
-	// return the number of bytes we processed
-	consumedBytes = essenceBytesCount + signatureBytesCount
-
-	// store bytes, so we don't have to marshal manually
-	result.bytes = bytes[:consumedBytes]
 
 	return
 }
 
-func FromStorage(key []byte) *Transaction {
-	id, err, _ := IdFromBytes(key)
-	if err != nil {
-		panic(err)
-	}
-
-	return &Transaction{
-		id: &id,
-	}
-}
-
 func (transaction *Transaction) Id() Id {
 	// acquire lock for reading id
 	transaction.idMutex.RLock()
@@ -281,9 +267,7 @@ func (transaction *Transaction) String() string {
 var _ objectstorage.StorableObject = &Transaction{}
 
 func (transaction *Transaction) ObjectStorageKey() []byte {
-	id := transaction.Id()
-
-	return id[:]
+	return transaction.Id().Bytes()
 }
 
 func (transaction *Transaction) Update(other objectstorage.StorableObject) {
@@ -295,8 +279,46 @@ func (transaction *Transaction) ObjectStorageValue() []byte {
 	return transaction.Bytes()
 }
 
-func (transaction *Transaction) UnmarshalObjectStorageValue(bytes []byte) (err error) {
-	_, err, _ = FromBytes(bytes, transaction)
+func (transaction *Transaction) UnmarshalObjectStorageValue(bytes []byte) (err error, consumedBytes int) {
+	// initialize helper
+	marshalUtil := marshalutil.New(bytes)
+
+	// unmarshal inputs
+	parsedInputs, err := marshalUtil.Parse(func(data []byte) (interface{}, error, int) { return InputsFromBytes(data) })
+	if err != nil {
+		return
+	}
+	transaction.inputs = parsedInputs.(*Inputs)
+
+	// unmarshal outputs
+	parsedOutputs, err := marshalUtil.Parse(func(data []byte) (interface{}, error, int) { return OutputsFromBytes(data) })
+	if err != nil {
+		return
+	}
+	transaction.outputs = parsedOutputs.(*Outputs)
+
+	// store essence bytes
+	essenceBytesCount := marshalUtil.ReadOffset()
+	transaction.essenceBytes = make([]byte, essenceBytesCount)
+	copy(transaction.essenceBytes, bytes[:essenceBytesCount])
+
+	// unmarshal outputs
+	parsedSignatures, err := marshalUtil.Parse(func(data []byte) (interface{}, error, int) { return SignaturesFromBytes(data) })
+	if err != nil {
+		return
+	}
+	transaction.signatures = parsedSignatures.(*Signatures)
+
+	// store signature bytes
+	signatureBytesCount := marshalUtil.ReadOffset() - essenceBytesCount
+	transaction.signatureBytes = make([]byte, signatureBytesCount)
+	copy(transaction.signatureBytes, bytes[essenceBytesCount:essenceBytesCount+signatureBytesCount])
+
+	// return the number of bytes we processed
+	consumedBytes = essenceBytesCount + signatureBytesCount
+
+	// store bytes, so we don't have to marshal manually
+	transaction.bytes = bytes[:consumedBytes]
 
 	return
 }
diff --git a/packages/gossip/manager.go b/packages/gossip/manager.go
index d3d6ccba..b8b676a9 100644
--- a/packages/gossip/manager.go
+++ b/packages/gossip/manager.go
@@ -6,7 +6,7 @@ import (
 	"net"
 	"sync"
 
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
 
 	"github.com/golang/protobuf/proto"
 	pb "github.com/iotaledger/goshimmer/packages/gossip/proto"
@@ -238,7 +238,7 @@ func (m *Manager) handlePacket(data []byte, p *peer.Peer) error {
 
 	switch pb.MType(data[0]) {
 
-	// Incoming Transaction
+	// Incoming Message
 	case pb.MTransaction:
 		msg := new(pb.Transaction)
 		if err := proto.Unmarshal(data[1:], msg); err != nil {
@@ -247,7 +247,7 @@ func (m *Manager) handlePacket(data []byte, p *peer.Peer) error {
 		m.log.Debugw("received message", "type", "TRANSACTION", "id", p.ID())
 		Events.TransactionReceived.Trigger(&TransactionReceivedEvent{Data: msg.GetData(), Peer: p})
 
-	// Incoming Transaction request
+	// Incoming Message request
 	case pb.MTransactionRequest:
 
 		msg := new(pb.TransactionRequest)
diff --git a/packages/gossip/manager_test.go b/packages/gossip/manager_test.go
index 220f5513..ab0e5b82 100644
--- a/packages/gossip/manager_test.go
+++ b/packages/gossip/manager_test.go
@@ -7,9 +7,6 @@ import (
 	"time"
 
 	"github.com/golang/protobuf/proto"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
-	pb "github.com/iotaledger/goshimmer/packages/gossip/proto"
-	"github.com/iotaledger/goshimmer/packages/gossip/server"
 	"github.com/iotaledger/hive.go/autopeering/peer"
 	"github.com/iotaledger/hive.go/autopeering/peer/service"
 	"github.com/iotaledger/hive.go/database/mapdb"
@@ -18,6 +15,10 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
 	"github.com/stretchr/testify/require"
+
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+	pb "github.com/iotaledger/goshimmer/packages/gossip/proto"
+	"github.com/iotaledger/goshimmer/packages/gossip/server"
 )
 
 const graceTime = 10 * time.Millisecond
diff --git a/pluginmgr/core/plugins.go b/pluginmgr/core/plugins.go
index c7faaaf7..8453fb5e 100644
--- a/pluginmgr/core/plugins.go
+++ b/pluginmgr/core/plugins.go
@@ -9,9 +9,9 @@ import (
 	"github.com/iotaledger/goshimmer/plugins/gossip"
 	"github.com/iotaledger/goshimmer/plugins/gracefulshutdown"
 	"github.com/iotaledger/goshimmer/plugins/logger"
+	"github.com/iotaledger/goshimmer/plugins/messagelayer"
 	"github.com/iotaledger/goshimmer/plugins/metrics"
 	"github.com/iotaledger/goshimmer/plugins/portcheck"
-	"github.com/iotaledger/goshimmer/plugins/tangle"
 	"github.com/iotaledger/hive.go/node"
 )
 
@@ -23,7 +23,7 @@ var PLUGINS = node.Plugins(
 	portcheck.PLUGIN,
 	database.PLUGIN,
 	autopeering.PLUGIN,
-	tangle.PLUGIN,
+	messagelayer.PLUGIN,
 	gossip.PLUGIN,
 	gracefulshutdown.PLUGIN,
 	metrics.PLUGIN,
diff --git a/plugins/gossip/gossip.go b/plugins/gossip/gossip.go
index d611032d..4d71f3a4 100644
--- a/plugins/gossip/gossip.go
+++ b/plugins/gossip/gossip.go
@@ -9,12 +9,12 @@ import (
 	"github.com/iotaledger/hive.go/logger"
 	"github.com/iotaledger/hive.go/netutil"
 
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
 	gp "github.com/iotaledger/goshimmer/packages/gossip"
 	"github.com/iotaledger/goshimmer/packages/gossip/server"
 	"github.com/iotaledger/goshimmer/plugins/autopeering/local"
 	"github.com/iotaledger/goshimmer/plugins/config"
-	"github.com/iotaledger/goshimmer/plugins/tangle"
+	"github.com/iotaledger/goshimmer/plugins/messagelayer"
 )
 
 var (
@@ -71,13 +71,13 @@ func start(shutdownSignal <-chan struct{}) {
 	log.Info("Stopping " + name + " ...")
 }
 
-func getTransaction(transactionId message.Id) (bytes []byte, err error) {
-	log.Debugw("get tx from db", "id", transactionId.String())
+func getTransaction(messageId message.Id) (bytes []byte, err error) {
+	log.Debugw("get tx from db", "id", messageId.String())
 
-	if !tangle.Instance.GetTransaction(transactionId).Consume(func(transaction *message.Transaction) {
-		bytes = transaction.Bytes()
+	if !messagelayer.Tangle.Message(messageId).Consume(func(message *message.Message) {
+		bytes = message.Bytes()
 	}) {
-		err = fmt.Errorf("transaction not found: hash=%s", transactionId)
+		err = fmt.Errorf("transaction not found: hash=%s", messageId)
 	}
 
 	return
diff --git a/plugins/gossip/plugin.go b/plugins/gossip/plugin.go
index ceca12f9..37c4f064 100644
--- a/plugins/gossip/plugin.go
+++ b/plugins/gossip/plugin.go
@@ -8,11 +8,11 @@ import (
 	"github.com/iotaledger/hive.go/logger"
 	"github.com/iotaledger/hive.go/node"
 
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transactionmetadata"
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/tangle"
 	"github.com/iotaledger/goshimmer/packages/gossip"
 	"github.com/iotaledger/goshimmer/packages/shutdown"
-	"github.com/iotaledger/goshimmer/plugins/tangle"
+	"github.com/iotaledger/goshimmer/plugins/messagelayer"
 )
 
 const name = "Gossip" // name of the plugin
@@ -73,20 +73,20 @@ func configureEvents() {
 
 	// configure flow of incoming transactions
 	gossip.Events.TransactionReceived.Attach(events.NewClosure(func(event *gossip.TransactionReceivedEvent) {
-		tangle.TransactionParser.Parse(event.Data, event.Peer)
+		messagelayer.TransactionParser.Parse(event.Data, event.Peer)
 	}))
 
 	// configure flow of outgoing transactions (gossip on solidification)
-	tangle.Instance.Events.TransactionSolid.Attach(events.NewClosure(func(cachedTransaction *message.CachedTransaction, transactionMetadata *transactionmetadata.CachedTransactionMetadata) {
+	messagelayer.Tangle.Events.TransactionSolid.Attach(events.NewClosure(func(cachedTransaction *message.CachedMessage, transactionMetadata *tangle.CachedMessageMetadata) {
 		transactionMetadata.Release()
 
-		cachedTransaction.Consume(func(transaction *message.Transaction) {
+		cachedTransaction.Consume(func(transaction *message.Message) {
 			mgr.SendTransaction(transaction.Bytes())
 		})
 	}))
 
 	// request missing transactions
-	tangle.TransactionRequester.Events.SendRequest.Attach(events.NewClosure(func(transactionId message.Id) {
+	messagelayer.TransactionRequester.Events.SendRequest.Attach(events.NewClosure(func(transactionId message.Id) {
 		mgr.RequestTransaction(transactionId[:])
 	}))
 }
diff --git a/plugins/graph/plugin.go b/plugins/graph/plugin.go
index c1aedcb1..f71c4ad6 100644
--- a/plugins/graph/plugin.go
+++ b/plugins/graph/plugin.go
@@ -6,7 +6,7 @@ import (
 	"time"
 
 	"github.com/iotaledger/goshimmer/plugins/config"
-	"github.com/iotaledger/goshimmer/plugins/tangle"
+	"github.com/iotaledger/goshimmer/plugins/messagelayer"
 
 	"golang.org/x/net/context"
 
@@ -102,10 +102,10 @@ func run(*node.Plugin) {
 
 	daemon.BackgroundWorker("Graph[NewTxWorker]", func(shutdownSignal <-chan struct{}) {
 		log.Info("Starting Graph[NewTxWorker] ... done")
-		tangle.Instance.Events.TransactionAttached.Attach(notifyNewTx)
+		messagelayer.Tangle.Events.TransactionAttached.Attach(notifyNewTx)
 		newTxWorkerPool.Start()
 		<-shutdownSignal
-		tangle.Instance.Events.TransactionAttached.Detach(notifyNewTx)
+		messagelayer.Tangle.Events.TransactionAttached.Detach(notifyNewTx)
 		newTxWorkerPool.Stop()
 		log.Info("Stopping Graph[NewTxWorker] ... done")
 	}, shutdown.ShutdownPriorityGraph)
diff --git a/plugins/tangle/plugin.go b/plugins/messagelayer/plugin.go
similarity index 54%
rename from plugins/tangle/plugin.go
rename to plugins/messagelayer/plugin.go
index 0b3f156d..51efe391 100644
--- a/plugins/tangle/plugin.go
+++ b/plugins/messagelayer/plugin.go
@@ -1,15 +1,14 @@
-package tangle
+package messagelayer
 
 import (
 	"github.com/iotaledger/hive.go/autopeering/peer"
 
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/tangle"
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/tipselector"
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/transactionparser"
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/transactionrequester"
 	"github.com/iotaledger/goshimmer/packages/binary/storageprefix"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transactionmetadata"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/tipselector"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/transactionparser"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/transactionrequester"
 	"github.com/iotaledger/goshimmer/packages/database"
 	"github.com/iotaledger/goshimmer/packages/shutdown"
 
@@ -27,7 +26,7 @@ var TransactionRequester *transactionrequester.TransactionRequester
 
 var TipSelector *tipselector.TipSelector
 
-var Instance *tangle.Tangle
+var Tangle *tangle.Tangle
 
 var log *logger.Logger
 
@@ -38,27 +37,27 @@ func configure(*node.Plugin) {
 	TransactionParser = transactionparser.New()
 	TransactionRequester = transactionrequester.New()
 	TipSelector = tipselector.New()
-	Instance = tangle.New(database.GetBadgerInstance(), storageprefix.MainNet)
+	Tangle = tangle.New(database.GetBadgerInstance(), storageprefix.MainNet)
 
 	// setup TransactionParser
-	TransactionParser.Events.TransactionParsed.Attach(events.NewClosure(func(transaction *message.Transaction, peer *peer.Peer) {
+	TransactionParser.Events.TransactionParsed.Attach(events.NewClosure(func(transaction *message.Message, peer *peer.Peer) {
 		// TODO: ADD PEER
 
-		Instance.AttachTransaction(transaction)
+		Tangle.AttachMessage(transaction)
 	}))
 
 	// setup TransactionRequester
-	Instance.Events.TransactionMissing.Attach(events.NewClosure(TransactionRequester.ScheduleRequest))
-	Instance.Events.MissingTransactionReceived.Attach(events.NewClosure(func(cachedTransaction *message.CachedTransaction, cachedTransactionMetadata *transactionmetadata.CachedTransactionMetadata) {
+	Tangle.Events.TransactionMissing.Attach(events.NewClosure(TransactionRequester.ScheduleRequest))
+	Tangle.Events.MissingTransactionReceived.Attach(events.NewClosure(func(cachedTransaction *message.CachedMessage, cachedTransactionMetadata *tangle.CachedMessageMetadata) {
 		cachedTransactionMetadata.Release()
 
-		cachedTransaction.Consume(func(transaction *message.Transaction) {
+		cachedTransaction.Consume(func(transaction *message.Message) {
 			TransactionRequester.StopRequest(transaction.GetId())
 		})
 	}))
 
 	// setup TipSelector
-	Instance.Events.TransactionSolid.Attach(events.NewClosure(func(cachedTransaction *message.CachedTransaction, cachedTransactionMetadata *transactionmetadata.CachedTransactionMetadata) {
+	Tangle.Events.TransactionSolid.Attach(events.NewClosure(func(cachedTransaction *message.CachedMessage, cachedTransactionMetadata *tangle.CachedMessageMetadata) {
 		cachedTransactionMetadata.Release()
 
 		cachedTransaction.Consume(TipSelector.AddTip)
@@ -70,6 +69,6 @@ func run(*node.Plugin) {
 		<-shutdownSignal
 
 		TransactionParser.Shutdown()
-		Instance.Shutdown()
+		Tangle.Shutdown()
 	}, shutdown.ShutdownPriorityTangle)
 }
diff --git a/plugins/metrics/plugin.go b/plugins/metrics/plugin.go
index 501e05f9..a07160af 100644
--- a/plugins/metrics/plugin.go
+++ b/plugins/metrics/plugin.go
@@ -8,17 +8,17 @@ import (
 	"github.com/iotaledger/hive.go/node"
 	"github.com/iotaledger/hive.go/timeutil"
 
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transactionmetadata"
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/tangle"
 	"github.com/iotaledger/goshimmer/packages/shutdown"
-	"github.com/iotaledger/goshimmer/plugins/tangle"
+	"github.com/iotaledger/goshimmer/plugins/messagelayer"
 )
 
 var PLUGIN = node.NewPlugin("Metrics", node.Enabled, configure, run)
 
 func configure(plugin *node.Plugin) {
 	// increase received TPS counter whenever we receive a new transaction
-	tangle.Instance.Events.TransactionAttached.Attach(events.NewClosure(func(transaction *message.CachedTransaction, metadata *transactionmetadata.CachedTransactionMetadata) {
+	messagelayer.Tangle.Events.TransactionAttached.Attach(events.NewClosure(func(transaction *message.CachedMessage, metadata *tangle.CachedMessageMetadata) {
 		transaction.Release()
 		metadata.Release()
 
diff --git a/plugins/spa/explorer_routes.go b/plugins/spa/explorer_routes.go
index 7be33868..448a57e9 100644
--- a/plugins/spa/explorer_routes.go
+++ b/plugins/spa/explorer_routes.go
@@ -4,8 +4,8 @@ import (
 	"net/http"
 	"sync"
 
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
-	"github.com/iotaledger/goshimmer/plugins/tangle"
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+	"github.com/iotaledger/goshimmer/plugins/messagelayer"
 
 	"github.com/labstack/echo"
 	"github.com/pkg/errors"
@@ -23,10 +23,10 @@ type ExplorerTx struct {
 	MWM                      int    `json:"mwm"`
 }
 
-func createExplorerTx(tx *message.Transaction) (*ExplorerTx, error) {
+func createExplorerTx(tx *message.Message) (*ExplorerTx, error) {
 	transactionId := tx.GetId()
 
-	txMetadata := tangle.Instance.GetTransactionMetadata(transactionId)
+	txMetadata := messagelayer.Tangle.GetTransactionMetadata(transactionId)
 
 	t := &ExplorerTx{
 		Hash:                     transactionId.String(),
@@ -116,7 +116,7 @@ func setupExplorerRoutes(routeGroup *echo.Group) {
 }
 
 func findTransaction(transactionId message.Id) (explorerTx *ExplorerTx, err error) {
-	if !tangle.Instance.GetTransaction(transactionId).Consume(func(transaction *message.Transaction) {
+	if !messagelayer.Tangle.GetTransaction(transactionId).Consume(func(transaction *message.Message) {
 		explorerTx, err = createExplorerTx(transaction)
 	}) {
 		err = errors.Wrapf(ErrNotFound, "tx hash: %s", transactionId.String())
diff --git a/plugins/spa/livefeed.go b/plugins/spa/livefeed.go
index adea985e..34851c6f 100644
--- a/plugins/spa/livefeed.go
+++ b/plugins/spa/livefeed.go
@@ -7,10 +7,10 @@ import (
 	"github.com/iotaledger/hive.go/events"
 	"github.com/iotaledger/hive.go/workerpool"
 
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transactionmetadata"
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/tangle"
 	"github.com/iotaledger/goshimmer/packages/shutdown"
-	"github.com/iotaledger/goshimmer/plugins/tangle"
+	"github.com/iotaledger/goshimmer/plugins/messagelayer"
 )
 
 var liveFeedWorkerCount = 1
@@ -19,7 +19,7 @@ var liveFeedWorkerPool *workerpool.WorkerPool
 
 func configureLiveFeed() {
 	liveFeedWorkerPool = workerpool.New(func(task workerpool.Task) {
-		task.Param(0).(*message.CachedTransaction).Consume(func(transaction *message.Transaction) {
+		task.Param(0).(*message.CachedMessage).Consume(func(transaction *message.Message) {
 			sendToAllWSClient(&msg{MsgTypeTx, &tx{transaction.GetId().String(), 0}})
 		})
 
@@ -29,7 +29,7 @@ func configureLiveFeed() {
 
 func runLiveFeed() {
 	newTxRateLimiter := time.NewTicker(time.Second / 10)
-	notifyNewTx := events.NewClosure(func(tx *message.CachedTransaction, metadata *transactionmetadata.CachedTransactionMetadata) {
+	notifyNewTx := events.NewClosure(func(tx *message.CachedMessage, metadata *tangle.CachedMessageMetadata) {
 		metadata.Release()
 
 		select {
@@ -41,11 +41,11 @@ func runLiveFeed() {
 	})
 
 	daemon.BackgroundWorker("SPA[TxUpdater]", func(shutdownSignal <-chan struct{}) {
-		tangle.Instance.Events.TransactionAttached.Attach(notifyNewTx)
+		messagelayer.Tangle.Events.TransactionAttached.Attach(notifyNewTx)
 		liveFeedWorkerPool.Start()
 		<-shutdownSignal
 		log.Info("Stopping SPA[TxUpdater] ...")
-		tangle.Instance.Events.TransactionAttached.Detach(notifyNewTx)
+		messagelayer.Tangle.Events.TransactionAttached.Detach(notifyNewTx)
 		newTxRateLimiter.Stop()
 		liveFeedWorkerPool.Stop()
 		log.Info("Stopping SPA[TxUpdater] ... done")
diff --git a/plugins/webapi/gtta/plugin.go b/plugins/webapi/gtta/plugin.go
index ebebea7b..6ecd48a8 100644
--- a/plugins/webapi/gtta/plugin.go
+++ b/plugins/webapi/gtta/plugin.go
@@ -3,11 +3,12 @@ package gtta
 import (
 	"net/http"
 
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
-	"github.com/iotaledger/goshimmer/plugins/tangle"
-	"github.com/iotaledger/goshimmer/plugins/webapi"
 	"github.com/iotaledger/hive.go/node"
 	"github.com/labstack/echo"
+
+	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/message"
+	"github.com/iotaledger/goshimmer/plugins/messagelayer"
+	"github.com/iotaledger/goshimmer/plugins/webapi"
 )
 
 var PLUGIN = node.NewPlugin("WebAPI GTTA Endpoint", node.Disabled, func(plugin *node.Plugin) {
@@ -15,7 +16,7 @@ var PLUGIN = node.NewPlugin("WebAPI GTTA Endpoint", node.Disabled, func(plugin *
 })
 
 func Handler(c echo.Context) error {
-	trunkTransactionId, branchTransactionId := tangle.TipSelector.GetTips()
+	trunkTransactionId, branchTransactionId := messagelayer.TipSelector.GetTips()
 
 	return c.JSON(http.StatusOK, Response{
 		TrunkTransaction:  trunkTransactionId,
diff --git a/plugins/webapi/spammer/plugin.go b/plugins/webapi/spammer/plugin.go
index 0b827a85..12de5fd2 100644
--- a/plugins/webapi/spammer/plugin.go
+++ b/plugins/webapi/spammer/plugin.go
@@ -5,7 +5,7 @@ import (
 
 	"github.com/iotaledger/goshimmer/packages/binary/spammer"
 	"github.com/iotaledger/goshimmer/packages/shutdown"
-	"github.com/iotaledger/goshimmer/plugins/tangle"
+	"github.com/iotaledger/goshimmer/plugins/messagelayer"
 	"github.com/iotaledger/goshimmer/plugins/webapi"
 
 	"github.com/iotaledger/hive.go/node"
@@ -16,7 +16,7 @@ var transactionSpammer *spammer.Spammer
 var PLUGIN = node.NewPlugin("Spammer", node.Disabled, configure, run)
 
 func configure(plugin *node.Plugin) {
-	transactionSpammer = spammer.New(tangle.TransactionParser, tangle.TipSelector)
+	transactionSpammer = spammer.New(messagelayer.TransactionParser, messagelayer.TipSelector)
 	webapi.Server.GET("spammer", handleRequest)
 }
 
-- 
GitLab