refactor: Flatten messagelayer (#732)

* refactor: Move messagelayer/message to tangle/

* refactor: Modify the method receiver and annotate the error messages

* refactor: Move messagelayer/payload to tangle/

* refactor: Modify the method receiver and annotate err messages in payload

* refactor: Move messagelayer/messagerequester to tangle/

* refactor: Modify the method receiver in requester

* refactor: Move messageparser/builtinfilter to tangle/

* refactor: Move messageparser/ to tangle/

* fix: Import fmt and minor fixes

* refactor: Move messagefactory/ to tangle/

* refactor: Move tipselector/ to tangle/

* refactor: Rename method receivers in tipselector

* refactor: Move messagelayer/tangle to tangle/

* refactor: Rename method receivers and annotate error messages in tangle

* refactor: Move messagelayer/test to tangle/

* fix: Update to the develop branch

* refactor: Create data payload in testing message creation

* fix: Fix 



* fix: Rename for consistency

* fix: Move message related const from payload.go to message.go

* refactor: Use single character for method receivers

* fix: Fix the unit test by using the correct variable name

* Feat: merged marshal changes

* Feat: removed superfluous test

* Fix: fixed wrong comment

* refactor: Annotate error messages in marshal functions

* refactor: Import fmt package

* refactor: Aggregate all filters into filter.go

* refactor: Rename Factory to MessageFactory to clarify the functionality

* refactor: Rename Parser to MessageParser to clarify the functionality

* refactor: Rename Requester to MessageRequester to clarify the functionality

* refactor: Rename Parse to FromMarshalUtil for naming consistency

* refactor: Fix comments

Co-authored-by: Hans Moog <hm@mkjc.net>

dapps/faucet/packages/payload/payload.go

@@ -3,6 +3,7 @@ package faucetpayload
 import (
 	"context"
 	"crypto"
+	"fmt"
 
 	// Only want to use init
 	_ "golang.org/x/crypto/blake2b"
@@ -43,6 +44,7 @@ func New(addr address.Address, powTarget int) (*Payload, error) {
 	powRelevantBytes := payloadBytes[:len(payloadBytes)-pow.NonceBytes]
 	nonce, err := powWorker.Mine(context.Background(), powRelevantBytes, powTarget)
 	if err != nil {
+		err = fmt.Errorf("failed to do PoW for faucet payload: %w", err)
 		return nil, err
 	}
 	p.nonce = nonce
@@ -62,23 +64,28 @@ func FromBytes(bytes []byte) (result *Payload, consumedBytes int, err error) {
 	// read data
 	result = &Payload{}
 	if _, err = marshalUtil.ReadUint32(); err != nil {
+		err = fmt.Errorf("failed to unmarshal payload size of faucet payload from bytes: %w", err)
 		return
 	}
 	result.payloadType, err = marshalUtil.ReadUint32()
 	if err != nil {
+		err = fmt.Errorf("failed to unmarshal payload type of faucet payload from bytes: %w", err)
 		return
 	}
 	addr, err := marshalUtil.ReadBytes(address.Length)
 	if err != nil {
+		err = fmt.Errorf("failed to unmarshal address of faucet payload from bytes: %w", err)
 		return
 	}
 	result.address, _, err = address.FromBytes(addr)
 	if err != nil {
+		err = fmt.Errorf("failed to unmarshal address of faucet payload from bytes: %w", err)
 		return
 	}
 
 	result.nonce, err = marshalUtil.ReadUint64()
 	if err != nil {
+		err = fmt.Errorf("failed to unmarshal nonce of faucet payload from bytes: %w", err)
 		return
 	}
 
@@ -123,6 +130,9 @@ func (faucetPayload *Payload) String() string {
 // PayloadUnmarshaler sets the generic unmarshaler.
 func PayloadUnmarshaler(data []byte) (payload payload.Payload, err error) {
 	payload, _, err = FromBytes(data)
+	if err != nil {
+		err = fmt.Errorf("failed to unmarshal faucet payload from bytes: %w", err)
+	}
 
 	return
 }

dapps/networkdelay/object.go

 package networkdelay
 
 import (
+	"fmt"
 	"sync"
 
 	"github.com/iotaledger/goshimmer/packages/binary/messagelayer/payload"
@@ -53,9 +54,11 @@ func FromBytes(bytes []byte) (result *Object, consumedBytes int, err error) {
 func Parse(marshalUtil *marshalutil.MarshalUtil) (result *Object, err error) {
 	// read information that are required to identify the object from the outside
 	if _, err = marshalUtil.ReadUint32(); err != nil {
+		err = fmt.Errorf("failed to parse payload size of networkdelay object: %w", err)
 		return
 	}
 	if _, err = marshalUtil.ReadUint32(); err != nil {
+		err = fmt.Errorf("failed to parse payload type of networkdelay object: %w", err)
 		return
 	}
 
@@ -63,12 +66,14 @@ func Parse(marshalUtil *marshalutil.MarshalUtil) (result *Object, err error) {
 	result = &Object{}
 	id, err := marshalUtil.ReadBytes(32)
 	if err != nil {
+		err = fmt.Errorf("failed to parse id of networkdelay object: %w", err)
 		return
 	}
 	copy(result.id[:], id)
 
 	// parse sent time
 	if result.sentTime, err = marshalUtil.ReadInt64(); err != nil {
+		err = fmt.Errorf("failed to parse sent time of networkdelay object: %w", err)
 		return
 	}
 

dapps/valuetransfers/packages/branchmanager/branch.go

@@ -56,6 +56,7 @@ func BranchFromBytes(bytes []byte) (result *Branch, consumedBytes int, err error
 // BranchFromObjectStorage is a factory method that creates a new Branch instance from the ObjectStorage.
 func BranchFromObjectStorage(key []byte, data []byte) (result objectstorage.StorableObject, err error) {
 	if result, _, err = BranchFromBytes(byteutils.ConcatBytes(key, data)); err != nil {
+		err = fmt.Errorf("failed to unmarshal branch from bytes: %w", err)
 		return
 	}
 
@@ -67,36 +68,44 @@ func ParseBranch(marshalUtil *marshalutil.MarshalUtil) (result *Branch, err erro
 	result = &Branch{}
 
 	if result.id, err = ParseBranchID(marshalUtil); err != nil {
+		err = fmt.Errorf("failed to parse branch ID: %w", err)
 		return
 	}
 	result.preferred, err = marshalUtil.ReadBool()
 	if err != nil {
+		err = fmt.Errorf("failed to parse 'preferred' of the branch: %w", err)
 		return
 	}
 	result.liked, err = marshalUtil.ReadBool()
 	if err != nil {
+		err = fmt.Errorf("failed to parse 'liked' of the branch: %w", err)
 		return
 	}
 	result.finalized, err = marshalUtil.ReadBool()
 	if err != nil {
+		err = fmt.Errorf("failed to parse 'finalized' of the branch: %w", err)
 		return
 	}
 	result.confirmed, err = marshalUtil.ReadBool()
 	if err != nil {
+		err = fmt.Errorf("failed to parse 'confirmed' of the branch: %w", err)
 		return
 	}
 	result.rejected, err = marshalUtil.ReadBool()
 	if err != nil {
+		err = fmt.Errorf("failed to parse 'rejected' of the branch: %w", err)
 		return
 	}
 	parentBranchCount, err := marshalUtil.ReadUint32()
 	if err != nil {
+		err = fmt.Errorf("failed to parse parentBranchCount of the branch: %w", err)
 		return
 	}
 	result.parentBranches = make([]BranchID, parentBranchCount)
 	for i := uint32(0); i < parentBranchCount; i++ {
 		result.parentBranches[i], err = ParseBranchID(marshalUtil)
 		if err != nil {
+			err = fmt.Errorf("failed to parse ID of the parent branch: %w", err)
 			return
 		}
 	}

dapps/valuetransfers/packages/branchmanager/child_branch.go

 package branchmanager
 
 import (
+	"fmt"
+
 	"github.com/iotaledger/hive.go/byteutils"
 	"github.com/iotaledger/hive.go/marshalutil"
 	"github.com/iotaledger/hive.go/objectstorage"
@@ -48,9 +50,11 @@ func ParseChildBranch(marshalUtil *marshalutil.MarshalUtil) (result *ChildBranch
 	result = &ChildBranch{}
 
 	if result.parentID, err = ParseBranchID(marshalUtil); err != nil {
+		err = fmt.Errorf("failed to parse parent branch ID: %w", err)
 		return
 	}
 	if result.childID, err = ParseBranchID(marshalUtil); err != nil {
+		err = fmt.Errorf("failed to parse child branch ID: %w", err)
 		return
 	}
 

dapps/valuetransfers/packages/branchmanager/conflict.go

 package branchmanager
 
 import (
+	"fmt"
 	"sync"
 
 	"github.com/iotaledger/hive.go/byteutils"
@@ -49,9 +50,11 @@ func ParseConflict(marshalUtil *marshalutil.MarshalUtil) (result *Conflict, err
 	result = &Conflict{}
 
 	if result.id, err = ParseConflictID(marshalUtil); err != nil {
+		err = fmt.Errorf("failed to parse conflict ID: %w", err)
 		return
 	}
 	if result.memberCount, err = marshalUtil.ReadUint32(); err != nil {
+		err = fmt.Errorf("failed to parse memberCount of conflict: %w", err)
 		return
 	}
 

dapps/valuetransfers/packages/branchmanager/conflict_member.go

 package branchmanager
 
 import (
+	"fmt"
+
 	"github.com/iotaledger/hive.go/marshalutil"
 	"github.com/iotaledger/hive.go/objectstorage"
 )
@@ -45,9 +47,11 @@ func ParseConflictMember(marshalUtil *marshalutil.MarshalUtil) (result *Conflict
 	result = &ConflictMember{}
 
 	if result.conflictID, err = ParseConflictID(marshalUtil); err != nil {
+		err = fmt.Errorf("failed to parse conflict ID: %w", err)
 		return
 	}
 	if result.branchID, err = ParseBranchID(marshalUtil); err != nil {
+		err = fmt.Errorf("failed to parse conflict branch ID: %w", err)
 		return
 	}
 

dapps/valuetransfers/packages/payload/id.go

@@ -33,6 +33,7 @@ func NewID(base58EncodedString string) (result ID, err error) {
 func ParseID(marshalUtil *marshalutil.MarshalUtil) (ID, error) {
 	id, err := marshalUtil.Parse(func(data []byte) (interface{}, int, error) { return IDFromBytes(data) })
 	if err != nil {
+		err = fmt.Errorf("failed to parse value payload ID: %w", err)
 		return ID{}, err
 	}
 

dapps/valuetransfers/packages/payload/payload.go

@@ -57,12 +57,14 @@ func FromObjectStorage(key []byte, data []byte) (result objectstorage.StorableOb
 	// parse the message
 	parsedPayload, err := Parse(marshalutil.New(data))
 	if err != nil {
+		err = fmt.Errorf("failed to parse value payload from object storage: %w", err)
 		return
 	}
 
-	// parse the ID from they key
+	// parse the ID from the key
 	payloadID, err := ParseID(marshalutil.New(key))
 	if err != nil {
+		err = fmt.Errorf("failed to parse value payload ID from object storage: %w", err)
 		return
 	}
 	parsedPayload.id = &payloadID
@@ -81,10 +83,12 @@ func Parse(marshalUtil *marshalutil.MarshalUtil) (result *Payload, err error) {
 	// read information that are required to identify the payload from the outside
 	_, err = marshalUtil.ReadUint32()
 	if err != nil {
+		err = fmt.Errorf("failed to parse payload size of value payload: %w", err)
 		return
 	}
 	_, err = marshalUtil.ReadUint32()
 	if err != nil {
+		err = fmt.Errorf("failed to parse payload type of value payload: %w", err)
 		return
 	}
 

dapps/valuetransfers/packages/tangle/attachment.go

 package tangle
 
 import (
+	"fmt"
+
 	"github.com/iotaledger/goshimmer/dapps/valuetransfers/packages/payload"
 	"github.com/iotaledger/goshimmer/dapps/valuetransfers/packages/transaction"
 	"github.com/iotaledger/hive.go/byteutils"
@@ -40,9 +42,11 @@ func AttachmentFromBytes(bytes []byte) (result *Attachment, consumedBytes int, e
 func ParseAttachment(marshalUtil *marshalutil.MarshalUtil) (result *Attachment, err error) {
 	result = &Attachment{}
 	if result.transactionID, err = transaction.ParseID(marshalUtil); err != nil {
+		err = fmt.Errorf("failed to parse transaction ID in attachment: %w", err)
 		return
 	}
 	if result.payloadID, err = payload.ParseID(marshalUtil); err != nil {
+		err = fmt.Errorf("failed to parse value payload ID in attachment: %w", err)
 		return
 	}
 
@@ -53,6 +57,9 @@ func ParseAttachment(marshalUtil *marshalutil.MarshalUtil) (result *Attachment,
 // returns the new object.
 func AttachmentFromObjectStorage(key []byte, data []byte) (result objectstorage.StorableObject, err error) {
 	result, _, err = AttachmentFromBytes(byteutils.ConcatBytes(key, data))
+	if err != nil {
+		err = fmt.Errorf("failed to parse attachment from object storage: %w", err)
+	}
 
 	return
 }

dapps/valuetransfers/packages/tangle/consumer.go

 package tangle
 
 import (
+	"fmt"
+
 	"github.com/iotaledger/goshimmer/dapps/valuetransfers/packages/address"
 	"github.com/iotaledger/goshimmer/dapps/valuetransfers/packages/transaction"
 	"github.com/iotaledger/hive.go/byteutils"
@@ -44,9 +46,11 @@ func ParseConsumer(marshalUtil *marshalutil.MarshalUtil) (result *Consumer, err
 	result = &Consumer{}
 
 	if result.consumedInput, err = transaction.ParseOutputID(marshalUtil); err != nil {
+		err = fmt.Errorf("failed to parse output ID of consumer: %w", err)
 		return
 	}
 	if result.transactionID, err = transaction.ParseID(marshalUtil); err != nil {
+		err = fmt.Errorf("failed to parse transaction ID of consumer: %w", err)
 		return
 	}
 
@@ -57,6 +61,9 @@ func ParseConsumer(marshalUtil *marshalutil.MarshalUtil) (result *Consumer, err
 // objectstorage. It is used by the objectstorage, to create new instances of this entity.
 func ConsumerFromObjectStorage(key []byte, _ []byte) (result objectstorage.StorableObject, err error) {
 	result, _, err = ConsumerFromBytes(key)
+	if err != nil {
+		err = fmt.Errorf("failed to parse consumer from object storage: %w", err)
+	}
 
 	return
 }

dapps/valuetransfers/packages/tangle/missingpayload.go

 package tangle
 
 import (
+	"fmt"
 	"time"
 
 	"github.com/iotaledger/goshimmer/dapps/valuetransfers/packages/payload"
@@ -41,9 +42,11 @@ func ParseMissingPayload(marshalUtil *marshalutil.MarshalUtil) (result *MissingP
 	result = &MissingPayload{}
 
 	if result.payloadID, err = payload.ParseID(marshalUtil); err != nil {
+		err = fmt.Errorf("failed to parse payload id of missing payload: %w", err)
 		return
 	}
 	if result.missingSince, err = marshalUtil.ReadTime(); err != nil {
+		err = fmt.Errorf("failed to parse missing time of missing payload: %w", err)
 		return
 	}
 
@@ -54,6 +57,9 @@ func ParseMissingPayload(marshalUtil *marshalutil.MarshalUtil) (result *MissingP
 // the content will be unmarshaled by an external caller using the binary.ObjectStorageValue interface.
 func MissingPayloadFromObjectStorage(key []byte, data []byte) (result objectstorage.StorableObject, err error) {
 	result, _, err = MissingPayloadFromBytes(byteutils.ConcatBytes(key, data))
+	if err != nil {
+		err = fmt.Errorf("failed to parse missing payload from object storage: %w", err)
+	}
 
 	return
 }

dapps/valuetransfers/packages/tangle/output.go

 package tangle
 
 import (
+	"fmt"
 	"sync"
 	"time"
 
@@ -73,51 +74,65 @@ func ParseOutput(marshalUtil *marshalutil.MarshalUtil) (result *Output, err erro
 	result = &Output{}
 
 	if result.address, err = address.Parse(marshalUtil); err != nil {
+		err = fmt.Errorf("failed to parse address of output: %w", err)
 		return
 	}
 	if result.transactionID, err = transaction.ParseID(marshalUtil); err != nil {
+		err = fmt.Errorf("failed to parse transaction ID of output: %w", err)
 		return
 	}
 	if result.branchID, err = branchmanager.ParseBranchID(marshalUtil); err != nil {
+		err = fmt.Errorf("failed to parse branch ID of output: %w", err)
 		return
 	}
 	if result.solid, err = marshalUtil.ReadBool(); err != nil {
+		err = fmt.Errorf("failed to parse 'solid' of output: %w", err)
 		return
 	}
 	if result.solidificationTime, err = marshalUtil.ReadTime(); err != nil {
+		err = fmt.Errorf("failed to parse solidification time of output: %w", err)
 		return
 	}
 	if result.firstConsumer, err = transaction.ParseID(marshalUtil); err != nil {
+		err = fmt.Errorf("failed to parse transaction ID of first consumer of output: %w", err)
 		return
 	}
 	consumerCount, err := marshalUtil.ReadUint32()
 	if err != nil {
+		err = fmt.Errorf("failed to parse consumer count of output: %w", err)
 		return
 	}
 	if result.preferred, err = marshalUtil.ReadBool(); err != nil {
+		err = fmt.Errorf("failed to parse 'preferred' of output: %w", err)
 		return
 	}
 	if result.finalized, err = marshalUtil.ReadBool(); err != nil {
+		err = fmt.Errorf("failed to parse 'finalized' of output: %w", err)
 		return
 	}
 	if result.liked, err = marshalUtil.ReadBool(); err != nil {
+		err = fmt.Errorf("failed to parse 'liked' of output: %w", err)
 		return
 	}
 	if result.confirmed, err = marshalUtil.ReadBool(); err != nil {
+		err = fmt.Errorf("failed to parse 'confirmed' of output: %w", err)
 		return
 	}
 	if result.rejected, err = marshalUtil.ReadBool(); err != nil {
+		err = fmt.Errorf("failed to parse 'rejected' of output: %w", err)
 		return
 	}
 	result.consumerCount = int(consumerCount)
 	balanceCount, err := marshalUtil.ReadUint32()
 	if err != nil {
+		err = fmt.Errorf("failed to parse balance count of output: %w", err)
 		return
 	}
 	result.balances = make([]*balance.Balance, balanceCount)
 	for i := uint32(0); i < balanceCount; i++ {
 		result.balances[i], err = balance.Parse(marshalUtil)
 		if err != nil {
+			err = fmt.Errorf("failed to parse balance of output: %w", err)
 			return
 		}
 	}
@@ -130,6 +145,9 @@ func ParseOutput(marshalUtil *marshalutil.MarshalUtil) (result *Output, err erro
 // it gets handed over to UnmarshalObjectStorageValue (by the ObjectStorage).
 func OutputFromObjectStorage(key []byte, data []byte) (result objectstorage.StorableObject, err error) {
 	result, _, err = OutputFromBytes(byteutils.ConcatBytes(key, data))
+	if err != nil {
+		err = fmt.Errorf("failed to parse output from object storage: %w", err)
+	}
 
 	return
 }

dapps/valuetransfers/packages/tangle/payloadapprover.go

 package tangle
 
 import (
+	"fmt"
+
 	"github.com/iotaledger/goshimmer/dapps/valuetransfers/packages/payload"
 	"github.com/iotaledger/hive.go/byteutils"
 	"github.com/iotaledger/hive.go/marshalutil"
@@ -38,9 +40,11 @@ func PayloadApproverFromBytes(bytes []byte) (result *PayloadApprover, consumedBy
 func ParsePayloadApprover(marshalUtil *marshalutil.MarshalUtil) (result *PayloadApprover, err error) {
 	result = &PayloadApprover{}
 	if result.referencedPayloadID, err = payload.ParseID(marshalUtil); err != nil {
+		err = fmt.Errorf("failed to parse payload id of approver: %w", err)
 		return
 	}
 	if result.approvingPayloadID, err = payload.ParseID(marshalUtil); err != nil {
+		err = fmt.Errorf("failed to parse payload id of approver: %w", err)
 		return
 	}
 
@@ -52,6 +56,9 @@ func ParsePayloadApprover(marshalUtil *marshalutil.MarshalUtil) (result *Payload
 // method.
 func PayloadApproverFromObjectStorage(key []byte, _ []byte) (result objectstorage.StorableObject, err error) {
 	result, _, err = PayloadMetadataFromBytes(key)
+	if err != nil {
+		err = fmt.Errorf("failed to parse approver from object storage: %w", err)
+	}
 
 	return
 }

dapps/valuetransfers/packages/tangle/payloadmetadata.go

 package tangle
 
 import (
+	"fmt"
 	"sync"
 	"time"
 
@@ -55,24 +56,31 @@ func PayloadMetadataFromBytes(bytes []byte) (result *PayloadMetadata, consumedBy
 func ParsePayloadMetadata(marshalUtil *marshalutil.MarshalUtil) (result *PayloadMetadata, err error) {
 	result = &PayloadMetadata{}
 	if result.payloadID, err = payload.ParseID(marshalUtil); err != nil {
+		err = fmt.Errorf("failed to parse payload id of payload metadata: %w", err)
 		return
 	}
 	if result.solidificationTime, err = marshalUtil.ReadTime(); err != nil {
+		err = fmt.Errorf("failed to parse solidification time of payload metadata: %w", err)
 		return
 	}
 	if result.solid, err = marshalUtil.ReadBool(); err != nil {
+		err = fmt.Errorf("failed to parse 'solid' of payload metadata: %w", err)
 		return
 	}
 	if result.liked, err = marshalUtil.ReadBool(); err != nil {
+		err = fmt.Errorf("failed to parse 'liked' of payload metadata: %w", err)
 		return
 	}
 	if result.confirmed, err = marshalUtil.ReadBool(); err != nil {
+		err = fmt.Errorf("failed to parse 'confirmed' of payload metadata: %w", err)
 		return
 	}
 	if result.rejected, err = marshalUtil.ReadBool(); err != nil {
+		err = fmt.Errorf("failed to parse 'rejected' of payload metadata: %w", err)
 		return
 	}
 	if result.branchID, err = branchmanager.ParseBranchID(marshalUtil); err != nil {
+		err = fmt.Errorf("failed to parse branch ID of payload metadata: %w", err)
 		return
 	}
 
@@ -83,6 +91,9 @@ func ParsePayloadMetadata(marshalUtil *marshalutil.MarshalUtil) (result *Payload
 // unmarshaled by an external caller using the binary.ObjectStorageValue interface.
 func PayloadMetadataFromObjectStorage(key []byte, data []byte) (result objectstorage.StorableObject, err error) {
 	result, _, err = PayloadMetadataFromBytes(byteutils.ConcatBytes(key, data))
+	if err != nil {
+		err = fmt.Errorf("failed to parse payload metadata from object storage: %w", err)
+	}
 
 	return
 }

dapps/valuetransfers/packages/tangle/transactionmetadata.go

 package tangle
 
 import (
+	"fmt"
 	"sync"
 	"time"
 
@@ -60,6 +61,9 @@ func TransactionMetadataFromBytes(bytes []byte) (result *TransactionMetadata, co
 // it gets handed over to UnmarshalObjectStorageValue (by the ObjectStorage).
 func TransactionMetadataFromObjectStorage(key []byte, data []byte) (result objectstorage.StorableObject, err error) {
 	result, _, err = TransactionMetadataFromBytes(byteutils.ConcatBytes(key, data))
+	if err != nil {
+		err = fmt.Errorf("failed to parse transaction metadata from object storage: %w", err)
+	}
 
 	return
 }
@@ -69,33 +73,43 @@ func ParseTransactionMetadata(marshalUtil *marshalutil.MarshalUtil) (result *Tra
 	result = &TransactionMetadata{}
 
 	if result.id, err = transaction.ParseID(marshalUtil); err != nil {
+		err = fmt.Errorf("failed to parse transaction ID of transaction metadata: %w", err)
 		return
 	}
 	if result.branchID, err = branchmanager.ParseBranchID(marshalUtil); err != nil {
+		err = fmt.Errorf("failed to parse branch ID of transaction metadata: %w", err)
 		return
 	}
 	if result.solidificationTime, err = marshalUtil.ReadTime(); err != nil {
+		err = fmt.Errorf("failed to parse solidification time of transaction metadata: %w", err)
 		return
 	}
 	if result.finalizationTime, err = marshalUtil.ReadTime(); err != nil {
+		err = fmt.Errorf("failed to parse finalization time of transaction metadata: %w", err)
 		return
 	}
 	if result.solid, err = marshalUtil.ReadBool(); err != nil {
+		err = fmt.Errorf("failed to parse 'solid' of transaction metadata: %w", err)
 		return
 	}
 	if result.preferred, err = marshalUtil.ReadBool(); err != nil {
+		err = fmt.Errorf("failed to parse 'preferred' of transaction metadata: %w", err)
 		return
 	}
 	if result.finalized, err = marshalUtil.ReadBool(); err != nil {
+		err = fmt.Errorf("failed to parse 'finalized' of transaction metadata: %w", err)
 		return
 	}
 	if result.liked, err = marshalUtil.ReadBool(); err != nil {
+		err = fmt.Errorf("failed to parse 'liked' of transaction metadata: %w", err)
 		return
 	}
 	if result.confirmed, err = marshalUtil.ReadBool(); err != nil {
+		err = fmt.Errorf("failed to parse 'confirmed' of transaction metadata: %w", err)
 		return
 	}
 	if result.rejected, err = marshalUtil.ReadBool(); err != nil {
+		err = fmt.Errorf("failed to parse 'rejected' of transaction metadata: %w", err)
 		return
 	}
 

dapps/valuetransfers/packages/transaction/transaction.go

@@ -78,11 +78,13 @@ func FromObjectStorage(key []byte, data []byte) (result objectstorage.StorableOb
 	// parse the message
 	transaction, err := Parse(marshalutil.New(data))
 	if err != nil {
+		err = fmt.Errorf("failed to parse transaction from object storage: %w", err)
 		return
 	}
 
 	id, err := ParseID(marshalutil.New(key))
 	if err != nil {
+		err = fmt.Errorf("failed to parse transaction ID from object storage: %w", err)
 		return
 	}
 	transaction.id = &id
@@ -104,6 +106,7 @@ func Parse(marshalUtil *marshalutil.MarshalUtil) (result *Transaction, err error
 	// unmarshal inputs
 	parsedInputs, err := marshalUtil.Parse(func(data []byte) (interface{}, int, error) { return InputsFromBytes(data) })
 	if err != nil {
+		err = fmt.Errorf("failed to parse inputs of transaction: %w", err)
 		return
 	}
 	result.inputs = parsedInputs.(*Inputs)
@@ -111,6 +114,7 @@ func Parse(marshalUtil *marshalutil.MarshalUtil) (result *Transaction, err error
 	// unmarshal outputs
 	parsedOutputs, err := marshalUtil.Parse(func(data []byte) (interface{}, int, error) { return OutputsFromBytes(data) })
 	if err != nil {
+		err = fmt.Errorf("failed to parse outputs of transaction: %w", err)
 		return
 	}
 	result.outputs = parsedOutputs.(*Outputs)
@@ -119,12 +123,14 @@ func Parse(marshalUtil *marshalutil.MarshalUtil) (result *Transaction, err error
 	var dataPayloadSize uint32
 	dataPayloadSize, err = marshalUtil.ReadUint32()
 	if err != nil {
+		err = fmt.Errorf("failed to parse data payload size of transaction: %w", err)
 		return
 	}
 
 	// unmarshal data payload
 	result.dataPayload, err = marshalUtil.ReadBytes(int(dataPayloadSize))
 	if err != nil {
+		err = fmt.Errorf("failed to parse data payload of transaction: %w", err)
 		return
 	}
 
@@ -132,12 +138,14 @@ func Parse(marshalUtil *marshalutil.MarshalUtil) (result *Transaction, err error
 	essenceBytesCount := marshalUtil.ReadOffset() - readOffsetStart
 	result.essenceBytes, err = marshalUtil.ReadBytes(essenceBytesCount, readOffsetStart)
 	if err != nil {
+		err = fmt.Errorf("failed to parse essence bytes of transaction: %w", err)
 		return
 	}
 
-	// unmarshal outputs
+	// unmarshal signatures
 	parsedSignatures, err := marshalUtil.Parse(func(data []byte) (interface{}, int, error) { return SignaturesFromBytes(data) })
 	if err != nil {
+		err = fmt.Errorf("failed to parse signatures of transaction: %w", err)
 		return
 	}
 	result.signatures = parsedSignatures.(*Signatures)
@@ -146,12 +154,14 @@ func Parse(marshalUtil *marshalutil.MarshalUtil) (result *Transaction, err error
 	signatureBytesCount := marshalUtil.ReadOffset() - readOffsetStart - essenceBytesCount
 	result.signatureBytes, err = marshalUtil.ReadBytes(signatureBytesCount, readOffsetStart+essenceBytesCount)
 	if err != nil {
+		err = fmt.Errorf("failed to parse signature bytes of transaction: %w", err)
 		return
 	}
 
 	// store bytes, so we don't have to marshal manually
 	result.bytes, err = marshalUtil.ReadBytes(essenceBytesCount+signatureBytesCount, readOffsetStart)
 	if err != nil {
+		err = fmt.Errorf("failed to parse bytes of transaction: %w", err)
 		return
 	}
 

packages/binary/drng/payload/payload.go

 package payload
 
 import (
+	"fmt"
 	"sync"
 
 	"github.com/iotaledger/goshimmer/packages/binary/drng/payload/header"
@@ -35,6 +36,7 @@ func New(header header.Header, data []byte) *Payload {
 func Parse(marshalUtil *marshalutil.MarshalUtil) (*Payload, error) {
 	payload, err := marshalUtil.Parse(func(data []byte) (interface{}, int, error) { return FromBytes(data) })
 	if err != nil {
+		err = fmt.Errorf("failed to parse drng payload: %w", err)
 		return &Payload{}, err
 	}
 	return payload.(*Payload), nil
@@ -50,20 +52,24 @@ func FromBytes(bytes []byte) (result *Payload, consumedBytes int, err error) {
 	result = &Payload{}
 	len, err := marshalUtil.ReadUint32()
 	if err != nil {
+		err = fmt.Errorf("failed to parse payload size of drng payload: %w", err)
 		return
 	}
 
 	if _, err = marshalUtil.ReadUint32(); err != nil {
+		err = fmt.Errorf("failed to parse payload type of drng payload: %w", err)
 		return
 	}
 
 	// parse header
 	if result.Header, err = header.Parse(marshalUtil); err != nil {
+		err = fmt.Errorf("failed to parse header of drng payload: %w", err)
 		return
 	}
 
 	// parse data
 	if result.Data, err = marshalUtil.ReadBytes(int(len - header.Length)); err != nil {
+		err = fmt.Errorf("failed to parse data of drng payload: %w", err)
 		return
 	}
 

packages/binary/drng/subtypes/collectivebeacon/payload/payload.go

 package payload
 
 import (
+	"fmt"
 	"sync"
 
 	"github.com/iotaledger/hive.go/stringify"
@@ -43,6 +44,7 @@ func New(instanceID uint32, round uint64, prevSignature, signature, dpk []byte)
 func Parse(marshalUtil *marshalutil.MarshalUtil) (*Payload, error) {
 	unmarshalledPayload, err := marshalUtil.Parse(func(data []byte) (interface{}, int, error) { return FromBytes(data) })
 	if err != nil {
+		err = fmt.Errorf("failed to parse collective beacon payload: %w", err)
 		return nil, err
 	}
 	_payload := unmarshalledPayload.(*Payload)
@@ -58,35 +60,42 @@ func FromBytes(bytes []byte) (result *Payload, consumedBytes int, err error) {
 
 	// read information that are required to identify the payload from the outside
 	if _, err = marshalUtil.ReadUint32(); err != nil {
+		err = fmt.Errorf("failed to parse payload size of collective beacon payload: %w", err)
 		return
 	}
 	if _, err = marshalUtil.ReadUint32(); err != nil {
+		err = fmt.Errorf("failed to parse payload type of collective beacon payload: %w", err)
 		return
 	}
 
 	// parse header
 	result = &Payload{}
 	if result.Header, err = header.Parse(marshalUtil); err != nil {
+		err = fmt.Errorf("failed to parse header of collective beacon payload: %w", err)
 		return
 	}
 
 	// parse round
 	if result.Round, err = marshalUtil.ReadUint64(); err != nil {
+		err = fmt.Errorf("failed to parse round of collective beacon payload: %w", err)
 		return
 	}
 
 	// parse prevSignature
 	if result.PrevSignature, err = marshalUtil.ReadBytes(SignatureSize); err != nil {
+		err = fmt.Errorf("failed to parse prevSignature of collective beacon payload: %w", err)
 		return
 	}
 
 	// parse current signature
 	if result.Signature, err = marshalUtil.ReadBytes(SignatureSize); err != nil {
+		err = fmt.Errorf("failed to parse current signature of collective beacon payload: %w", err)
 		return
 	}
 
 	// parse distributed public key
 	if result.Dpk, err = marshalUtil.ReadBytes(PublicKeySize); err != nil {
+		err = fmt.Errorf("failed to parse distributed public key of collective beacon payload: %w", err)
 		return
 	}
 

packages/tangle/approver.go

+package tangle
+
+import (
+	"fmt"
+
+	"github.com/iotaledger/hive.go/marshalutil"
+	"github.com/iotaledger/hive.go/objectstorage"
+	"github.com/iotaledger/hive.go/stringify"
+)
+
+// Approver is an approver of a given referenced message.
+type Approver struct {
+	objectstorage.StorableObjectFlags
+	// the message which got referenced by the approver message.
+	referencedMessageID MessageID
+	// the message which approved/referenced the given referenced message.
+	approverMessageID MessageID
+}
+
+// NewApprover creates a new approver relation to the given approved/referenced message.
+func NewApprover(referencedMessageID MessageID, approverMessageID MessageID) *Approver {
+	approver := &Approver{
+		referencedMessageID: referencedMessageID,
+		approverMessageID:   approverMessageID,
+	}
+	return approver
+}
+
+// ApproverFromBytes parses the given bytes into an approver.
+func ApproverFromBytes(bytes []byte) (result *Approver, consumedBytes int, err error) {
+	marshalUtil := marshalutil.New(bytes)
+	result, err = ApproverFromMarshalUtil(marshalUtil)
+	consumedBytes = marshalUtil.ReadOffset()
+	return
+}
+
+// ApproverFromMarshalUtil parses a new approver from the given marshal util.
+func ApproverFromMarshalUtil(marshalUtil *marshalutil.MarshalUtil) (result *Approver, err error) {
+	result = &Approver{}
+
+	if result.referencedMessageID, err = MessageIDFromMarshalUtil(marshalUtil); err != nil {
+		err = fmt.Errorf("failed to parse referenced message ID of approver: %w", err)
+		return
+	}
+	if result.approverMessageID, err = MessageIDFromMarshalUtil(marshalUtil); err != nil {
+		err = fmt.Errorf("failed to parse approver message ID of approver: %w", err)
+		return
+	}
+
+	return
+}
+
+// ApproverFromObjectStorage is the factory method for Approvers stored in the ObjectStorage.
+func ApproverFromObjectStorage(key []byte, _ []byte) (result objectstorage.StorableObject, err error) {
+	result, _, err = ApproverFromBytes(key)
+	if err != nil {
+		err = fmt.Errorf("failed to parse approver from object storage: %w", err)
+	}
+
+	return
+}
+
+// ReferencedMessageID returns the ID of the message which is referenced by the approver.
+func (a *Approver) ReferencedMessageID() MessageID {
+	return a.referencedMessageID
+}
+
+// ApproverMessageID returns the ID of the message which referenced the given approved message.
+func (a *Approver) ApproverMessageID() MessageID {
+	return a.approverMessageID
+}
+
+// Bytes returns the bytes of the approver.
+func (a *Approver) Bytes() []byte {
+	return a.ObjectStorageKey()
+}
+
+// String returns the string representation of the approver.
+func (a *Approver) String() string {
+	return stringify.Struct("Approver",
+		stringify.StructField("referencedMessageID", a.ReferencedMessageID()),
+		stringify.StructField("approverMessageID", a.ApproverMessageID()),
+	)
+}
+
+// ObjectStorageKey marshals the keys of the stored approver into a byte array.
+// This includes the referencedMessageID and the approverMessageID.
+func (a *Approver) ObjectStorageKey() []byte {
+	return marshalutil.New().
+		WriteBytes(a.referencedMessageID.Bytes()).
+		WriteBytes(a.approverMessageID.Bytes()).
+		Bytes()
+}
+
+// ObjectStorageValue returns the value of the stored approver object.
+func (a *Approver) ObjectStorageValue() (result []byte) {
+	return
+}
+
+// Update updates the approver.
+// This should should never happen and will panic if attempted.
+func (a *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{}
+
+// CachedApprover is a wrapper for a stored cached object representing an approver.
+type CachedApprover struct {
+	objectstorage.CachedObject
+}
+
+// Unwrap unwraps the cached approver into the underlying approver.
+// If stored object cannot be cast into an approver or has been deleted, it returns nil.
+func (c *CachedApprover) Unwrap() *Approver {
+	untypedObject := c.Get()
+	if untypedObject == nil {
+		return nil
+	}
+
+	typedObject := untypedObject.(*Approver)
+	if typedObject == nil || typedObject.IsDeleted() {
+		return nil
+	}
+
+	return typedObject
+
+}
+
+// Consume consumes the cachedApprover.
+// It releases the object when the callback is done.
+// It returns true if the callback was called.
+func (c *CachedApprover) Consume(consumer func(approver *Approver)) (consumed bool) {
+	return c.CachedObject.Consume(func(object objectstorage.StorableObject) {
+		consumer(object.(*Approver))
+	})
+}
+
+// CachedApprovers defines a slice of *CachedApprover.
+type CachedApprovers []*CachedApprover
+
+// Consume calls *CachedApprover.Consume on element in the list.
+func (c CachedApprovers) Consume(consumer func(approver *Approver)) (consumed bool) {
+	for _, cachedApprover := range c {
+		consumed = cachedApprover.Consume(func(approver *Approver) {
+			consumer(approver)
+		}) || consumed
+	}
+
+	return
+}

packages/tangle/events.go

+package tangle
+
+import (
+	"github.com/iotaledger/hive.go/autopeering/peer"
+	"github.com/iotaledger/hive.go/events"
+)
+
+// Events represents events happening on the base layer Tangle.
+type Events struct {
+	// Fired when a message has been attached.
+	MessageAttached *events.Event
+	// Fired when a message has been solid, i.e. its past cone
+	// is known and in the database.
+	MessageSolid *events.Event
+	// Fired when a message which was previously marked as missing was received.
+	MissingMessageReceived *events.Event
+	// Fired when a message is missing which is needed to solidify a given approver message.
+	MessageMissing *events.Event
+	// Fired when a message was missing for too long and is
+	// therefore considered to be unsolidifiable.
+	MessageUnsolidifiable *events.Event
+	// Fired when a message was removed from storage.
+	MessageRemoved *events.Event
+}
+
+// CachedMessageEvent represents the parameters of cachedMessageEvent
+type CachedMessageEvent struct {
+	Message         *CachedMessage
+	MessageMetadata *CachedMessageMetadata
+}
+
+func newEvents() *Events {
+	return &Events{
+		MessageAttached:        events.NewEvent(cachedMessageEvent),
+		MessageSolid:           events.NewEvent(cachedMessageEvent),
+		MissingMessageReceived: events.NewEvent(cachedMessageEvent),
+		MessageMissing:         events.NewEvent(messageIDEvent),
+		MessageUnsolidifiable:  events.NewEvent(messageIDEvent),
+		MessageRemoved:         events.NewEvent(messageIDEvent),
+	}
+}
+
+// MessageTipSelectorEvents represents event happening on the tip-selector.
+type MessageTipSelectorEvents struct {
+	// Fired when a tip is added.
+	TipAdded *events.Event
+	// Fired when a tip is removed.
+	TipRemoved *events.Event
+}
+
+func newMessageTipSelectorEvents() *MessageTipSelectorEvents {
+	return &MessageTipSelectorEvents{
+		TipAdded:   events.NewEvent(messageIDEvent),
+		TipRemoved: events.NewEvent(messageIDEvent),
+	}
+}
+
+// MessageFactoryEvents represents events happening on a message factory.
+type MessageFactoryEvents struct {
+	// Fired when a message is built including tips, sequence number and other metadata.
+	MessageConstructed *events.Event
+	// Fired when an error occurred.
+	Error *events.Event
+}
+
+func newMessageFactoryEvents() *MessageFactoryEvents {
+	return &MessageFactoryEvents{
+		MessageConstructed: events.NewEvent(messageConstructedEvent),
+		Error:              events.NewEvent(events.ErrorCaller),
+	}
+}
+
+// MessageParserEvents represents events happening on a message parser.
+type MessageParserEvents struct {
+	// Fired when a message was parsed.
+	MessageParsed *events.Event
+	// Fired when submitted bytes are rejected by a filter.
+	BytesRejected *events.Event
+	// Fired when a message got rejected by a filter.
+	MessageRejected *events.Event
+}
+
+// MessageParsedEvent represents the parameters of messageParsedEvent
+type MessageParsedEvent struct {
+	Message *Message
+	Peer    *peer.Peer
+}
+
+// BytesRejectedEvent represents the parameters of bytesRejectedEvent
+type BytesRejectedEvent struct {
+	Bytes []byte
+	Peer  *peer.Peer
+}
+
+// MessageRejectedEvent represents the parameters of messageRejectedEvent
+type MessageRejectedEvent struct {
+	Message *Message
+	Peer    *peer.Peer
+}
+
+func newMessageParserEvents() *MessageParserEvents {
+	return &MessageParserEvents{
+		MessageParsed:   events.NewEvent(messageParsedEvent),
+		BytesRejected:   events.NewEvent(bytesRejectedEvent),
+		MessageRejected: events.NewEvent(messageRejectedEvent),
+	}
+}
+
+// MessageRequesterEvents represents events happening on a message requester.
+type MessageRequesterEvents struct {
+	// Fired when a request for a given message should be sent.
+	SendRequest *events.Event
+	// MissingMessageAppeared is triggered when a message is actually present in the node's db although it was still being requested.
+	MissingMessageAppeared *events.Event
+}
+
+// SendRequestEvent represents the parameters of sendRequestEvent
+type SendRequestEvent struct {
+	ID MessageID
+}
+
+// MissingMessageAppearedEvent represents the parameters of missingMessageAppearedEvent
+type MissingMessageAppearedEvent struct {
+	ID MessageID
+}
+
+func newMessageRequesterEvents() *MessageRequesterEvents {
+	return &MessageRequesterEvents{
+		SendRequest:            events.NewEvent(sendRequestEvent),
+		MissingMessageAppeared: events.NewEvent(missingMessageAppearedEvent),
+	}
+}
+
+func sendRequestEvent(handler interface{}, params ...interface{}) {
+	handler.(func(*SendRequestEvent))(params[0].(*SendRequestEvent))
+}
+
+func missingMessageAppearedEvent(handler interface{}, params ...interface{}) {
+	handler.(func(*MissingMessageAppearedEvent))(params[0].(*MissingMessageAppearedEvent))
+}
+
+func messageParsedEvent(handler interface{}, params ...interface{}) {
+	handler.(func(*MessageParsedEvent))(params[0].(*MessageParsedEvent))
+}
+
+func bytesRejectedEvent(handler interface{}, params ...interface{}) {
+	handler.(func(*BytesRejectedEvent, error))(params[0].(*BytesRejectedEvent), params[1].(error))
+}
+
+func messageRejectedEvent(handler interface{}, params ...interface{}) {
+	handler.(func(*MessageRejectedEvent, error))(params[0].(*MessageRejectedEvent), params[1].(error))
+}
+
+func messageConstructedEvent(handler interface{}, params ...interface{}) {
+	handler.(func(*Message))(params[0].(*Message))
+}
+
+func messageIDEvent(handler interface{}, params ...interface{}) {
+	handler.(func(MessageID))(params[0].(MessageID))
+}
+
+func cachedMessageEvent(handler interface{}, params ...interface{}) {
+	handler.(func(*CachedMessageEvent))(cachedMessageRetain(params[0].(*CachedMessageEvent)))
+}
+
+func cachedMessageRetain(object *CachedMessageEvent) *CachedMessageEvent {
+	return &CachedMessageEvent{
+		Message:         object.Message.Retain(),
+		MessageMetadata: object.MessageMetadata.Retain(),
+	}
+}