Feat: Refactor and cleanup some code (#301)

* Feat: refactored the address

* Feat: started adding solidification of transferOutputs

* Feat: cleaned up checker code

* Feat: going to bed - good night world

* Feat: refactored transferoutput package

* Fix: fixed a bug from refactoring

* Refactor: removed old transferoutputmetadata package

* Refactor: started refactoring transfer package

* Refactor: refactored transfer/id package

* Refactor: moved transfer struct to new package

* Refactor: fixed issues after refactor

* Refactor: fixed sth

* Refactor: continued to move files

* Refactor: commit before migration of last refactored files

* Refactor: another refactor before move

* Refactor: refactor test

* Fix: fixed some bugs connected to refactor

* Refactor: continued refactor

* Refactor: fixed some bugs

* Refactor: does it work now?

* Feat: added a method to generate a random transferid

* Feat: rename transfer to transaction

* Refactor: refactor according to new names

* Refactor: continued to refactor transaction package

* Refactor: moved payload id to payload package

* Refactor: moved signatures to transaction package

* Refactor: moved signature to transaction

* Fix: fixed bug due to refactor

* Fix: fixed bugs due to refactor

* Refactor: fixed some bugs after refactor

* Fix: fixed additional bugs

* Fix: bug fix

* Refactor: moved signature to signaturescheme package

* Fix: fixed signatures test

* Fix: fixed bug in tangle

* Fix: fixed payloadmetadata test

* Fix: fixed payload test

* Refactor: moved payloadmetadata to payload package

* Fix: fixed some refactor bugs

* Fix: fixed a bug due to refactor

* Fix: fixed broken test

* Refactor: moved approver to payload package

* Refactor: moved missingpayload to payload package

* Refactor: refactored coloredbalance package

* Fix: fixed bug due to refactor

* Refactor: moved address signaturescheme to address package

* Fix: fixed refactor bug

* Feat: added missing outputs to tangle

* Fix: fixed issues due to refactor

* Refactor: started moving tangle classes to tangle package

* Refactor: moved payloadmetadata to tangle

* Fix: fixed bugs due to refactor

* Refactor: moved TransactionMetadata to tangle package

* Refactor: moved some files to tangle

* Fix: fixed bug due to refactor

* Feat: added TransactionMetadata storage

* Fix: fixed some issues

* Fix: fixed some issues

* Fix: fixed missing release

packages/binary/datastructure/orderedmap/orderedmap.go

@@ -66,20 +66,22 @@ func (orderedMap *OrderedMap) Set(key interface{}, newValue interface{}) bool {
 	return true
 }
 
-func (orderedMap *OrderedMap) ForEach(consumer func(key, value interface{}) bool) {
+func (orderedMap *OrderedMap) ForEach(consumer func(key, value interface{}) bool) bool {
 	orderedMap.mutex.RLock()
 	currentEntry := orderedMap.head
 	orderedMap.mutex.RUnlock()
 
 	for currentEntry != nil {
 		if !consumer(currentEntry.key, currentEntry.value) {
-			return
+			return false
 		}
 
 		orderedMap.mutex.RLock()
 		currentEntry = currentEntry.next
 		orderedMap.mutex.RUnlock()
 	}
+
+	return true
 }
 
 func (orderedMap *OrderedMap) Delete(key interface{}) bool {

packages/binary/spammer/spammer.go

@@ -7,8 +7,8 @@ import (
 	"github.com/iotaledger/hive.go/types"
 
 	"github.com/iotaledger/goshimmer/packages/binary/signature/ed25119"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transaction"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transaction/payload/data"
+	"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"
 )
@@ -53,7 +53,7 @@ func (spammer *Spammer) run(tps int, processId int64) {
 
 		trunkTransactionId, branchTransactionId := spammer.tipSelector.GetTips()
 		spammer.transactionParser.Parse(
-			transaction.New(trunkTransactionId, branchTransactionId, spammingIdentity, time.Now(), 0, data.New([]byte("SPAM"))).Bytes(),
+			message.New(trunkTransactionId, branchTransactionId, spammingIdentity, time.Now(), 0, data.New([]byte("SPAM"))).Bytes(),
 			nil,
 		)
 
@@ -75,7 +75,7 @@ func (spammer *Spammer) run(tps int, processId int64) {
 func (spammer *Spammer) sendBurst(transactions int, processId int64) {
 	spammingIdentity := ed25119.GenerateKeyPair()
 
-	previousTransactionId := transaction.EmptyId
+	previousTransactionId := message.EmptyId
 
 	burstBuffer := make([][]byte, transactions)
 	for i := 0; i < transactions; i++ {
@@ -83,7 +83,7 @@ func (spammer *Spammer) sendBurst(transactions int, processId int64) {
 			return
 		}
 
-		spamTransaction := transaction.New(previousTransactionId, previousTransactionId, spammingIdentity, time.Now(), 0, data.New([]byte("SPAM")))
+		spamTransaction := message.New(previousTransactionId, previousTransactionId, spammingIdentity, time.Now(), 0, data.New([]byte("SPAM")))
 		previousTransactionId = spamTransaction.GetId()
 		burstBuffer[i] = spamTransaction.Bytes()
 	}

packages/binary/tangle/events.go

@@ -3,7 +3,7 @@ package tangle
 import (
 	"github.com/iotaledger/hive.go/events"
 
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transaction"
+	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
 	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transactionmetadata"
 )
 
@@ -29,12 +29,12 @@ func newEvents() *Events {
 }
 
 func transactionIdEvent(handler interface{}, params ...interface{}) {
-	handler.(func(transaction.Id))(params[0].(transaction.Id))
+	handler.(func(message.Id))(params[0].(message.Id))
 }
 
 func cachedTransactionEvent(handler interface{}, params ...interface{}) {
-	handler.(func(*transaction.CachedTransaction, *transactionmetadata.CachedTransactionMetadata))(
-		params[0].(*transaction.CachedTransaction).Retain(),
+	handler.(func(*message.CachedTransaction, *transactionmetadata.CachedTransactionMetadata))(
+		params[0].(*message.CachedTransaction).Retain(),
 		params[1].(*transactionmetadata.CachedTransactionMetadata).Retain(),
 	)
 }

packages/binary/tangle/model/approver/approver.go

@@ -3,36 +3,36 @@ package approver
 import (
 	"github.com/iotaledger/hive.go/objectstorage"
 
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transaction"
+	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
 )
 
 type Approver struct {
 	objectstorage.StorableObjectFlags
 
 	storageKey            []byte
-	referencedTransaction transaction.Id
-	approvingTransaction  transaction.Id
+	referencedTransaction message.Id
+	approvingTransaction  message.Id
 }
 
-func New(referencedTransaction transaction.Id, approvingTransaction transaction.Id) *Approver {
+func New(referencedTransaction message.Id, approvingTransaction message.Id) *Approver {
 	approver := &Approver{
-		storageKey:            make([]byte, transaction.IdLength+transaction.IdLength),
+		storageKey:            make([]byte, message.IdLength+message.IdLength),
 		referencedTransaction: referencedTransaction,
 		approvingTransaction:  approvingTransaction,
 	}
 
-	copy(approver.storageKey[:transaction.IdLength], referencedTransaction[:])
-	copy(approver.storageKey[transaction.IdLength:], approvingTransaction[:])
+	copy(approver.storageKey[:message.IdLength], referencedTransaction[:])
+	copy(approver.storageKey[message.IdLength:], approvingTransaction[:])
 
 	return approver
 }
 
 func FromStorage(id []byte) (result objectstorage.StorableObject) {
 	approver := &Approver{
-		storageKey: make([]byte, transaction.IdLength+transaction.IdLength),
+		storageKey: make([]byte, message.IdLength+message.IdLength),
 	}
-	copy(approver.referencedTransaction[:], id[:transaction.IdLength])
-	copy(approver.approvingTransaction[:], id[transaction.IdLength:])
+	copy(approver.referencedTransaction[:], id[:message.IdLength])
+	copy(approver.approvingTransaction[:], id[message.IdLength:])
 	copy(approver.storageKey, id)
 
 	return approver
@@ -42,7 +42,7 @@ func (approver *Approver) GetStorageKey() []byte {
 	return approver.storageKey
 }
 
-func (approver *Approver) GetApprovingTransactionId() transaction.Id {
+func (approver *Approver) GetApprovingTransactionId() message.Id {
 	return approver.approvingTransaction
 }
 

packages/binary/tangle/model/transaction/cached_transaction.go → packages/binary/tangle/model/message/cached_transaction.go

-package transaction
+package message
 
 import (
 	"github.com/iotaledger/hive.go/objectstorage"

packages/binary/tangle/model/transaction/id.go → packages/binary/tangle/model/message/id.go

-package transaction
+package message
 
 import (
 	"fmt"

packages/binary/tangle/model/transaction/init.go → packages/binary/tangle/model/message/init.go

-package transaction
+package message
 
 import (
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transaction/payload"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transaction/payload/data"
+	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message/payload"
+	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message/payload/data"
 )
 
 func init() {

packages/binary/tangle/model/transaction/payload/data/data.go → packages/binary/tangle/model/message/payload/data/data.go

@@ -4,7 +4,7 @@ import (
 	"github.com/iotaledger/hive.go/stringify"
 
 	"github.com/iotaledger/goshimmer/packages/binary/marshalutil"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transaction/payload"
+	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message/payload"
 )
 
 type Data struct {

packages/binary/tangle/model/transaction/payload/data/init.go → packages/binary/tangle/model/message/payload/data/init.go

 package data
 
 import (
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transaction/payload"
+	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message/payload"
 )
 
 func init() {

packages/binary/tangle/model/transaction/test/transaction_test.go → packages/binary/tangle/model/message/test/transaction_test.go

@@ -11,8 +11,8 @@ import (
 	"github.com/panjf2000/ants/v2"
 
 	"github.com/iotaledger/goshimmer/packages/binary/signature/ed25119"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transaction"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transaction/payload/data"
+	"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 := transaction.New(transaction.EmptyId, transaction.EmptyId, ed25119.GenerateKeyPair(), time.Now(), 0, data.New([]byte("some data")))
+		tx := message.New(message.EmptyId, message.EmptyId, ed25119.GenerateKeyPair(), time.Now(), 0, data.New([]byte("some data")))
 
 		if marshaledTransaction, err := tx.MarshalBinary(); err != nil {
 			b.Error(err)
@@ -35,7 +35,7 @@ func BenchmarkVerifyDataTransactions(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 		currentIndex := i
 		pool.Submit(func() {
-			if tx, err, _ := transaction.FromBytes(transactions[currentIndex]); err != nil {
+			if tx, err, _ := message.FromBytes(transactions[currentIndex]); err != nil {
 				b.Error(err)
 			} else {
 				tx.VerifySignature()
@@ -49,9 +49,9 @@ func BenchmarkVerifyDataTransactions(b *testing.B) {
 func BenchmarkVerifySignature(b *testing.B) {
 	pool, _ := ants.NewPool(80, ants.WithNonblocking(false))
 
-	transactions := make([]*transaction.Transaction, b.N)
+	transactions := make([]*message.Transaction, b.N)
 	for i := 0; i < b.N; i++ {
-		transactions[i] = transaction.New(transaction.EmptyId, transaction.EmptyId, ed25119.GenerateKeyPair(), time.Now(), 0, data.New([]byte("test")))
+		transactions[i] = message.New(message.EmptyId, message.EmptyId, ed25119.GenerateKeyPair(), time.Now(), 0, data.New([]byte("test")))
 		transactions[i].Bytes()
 	}
 

packages/binary/tangle/model/transaction/transaction.go → packages/binary/tangle/model/message/transaction.go

-package transaction
+package message
 
 import (
 	"sync"
@@ -8,7 +8,7 @@ import (
 
 	"github.com/iotaledger/goshimmer/packages/binary/marshalutil"
 	"github.com/iotaledger/goshimmer/packages/binary/signature/ed25119"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transaction/payload"
+	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message/payload"
 
 	"github.com/iotaledger/hive.go/objectstorage"
 

packages/binary/tangle/model/missingtransaction/missingtransaction.go

@@ -3,18 +3,18 @@ package missingtransaction
 import (
 	"time"
 
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transaction"
+	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
 	"github.com/iotaledger/hive.go/objectstorage"
 )
 
 type MissingTransaction struct {
 	objectstorage.StorableObjectFlags
 
-	transactionId transaction.Id
+	transactionId message.Id
 	missingSince  time.Time
 }
 
-func New(transactionId transaction.Id) *MissingTransaction {
+func New(transactionId message.Id) *MissingTransaction {
 	return &MissingTransaction{
 		transactionId: transactionId,
 		missingSince:  time.Now(),
@@ -28,7 +28,7 @@ func FromStorage(key []byte) objectstorage.StorableObject {
 	return result
 }
 
-func (missingTransaction *MissingTransaction) GetTransactionId() transaction.Id {
+func (missingTransaction *MissingTransaction) GetTransactionId() message.Id {
 	return missingTransaction.transactionId
 }
 

packages/binary/tangle/model/transactionmetadata/transactionmetadata.go

@@ -6,13 +6,13 @@ import (
 
 	"github.com/iotaledger/hive.go/objectstorage"
 
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transaction"
+	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
 )
 
 type TransactionMetadata struct {
 	objectstorage.StorableObjectFlags
 
-	transactionId      transaction.Id
+	transactionId      message.Id
 	receivedTime       time.Time
 	solid              bool
 	solidificationTime time.Time
@@ -21,7 +21,7 @@ type TransactionMetadata struct {
 	solidificationTimeMutex sync.RWMutex
 }
 
-func New(transactionId transaction.Id) *TransactionMetadata {
+func New(transactionId message.Id) *TransactionMetadata {
 	return &TransactionMetadata{
 		transactionId: transactionId,
 		receivedTime:  time.Now(),

packages/binary/tangle/tangle.go

@@ -9,8 +9,8 @@ import (
 
 	"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/transaction"
 	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transactionmetadata"
 
 	"github.com/iotaledger/hive.go/async"
@@ -41,9 +41,9 @@ type Tangle struct {
 func New(badgerInstance *badger.DB, storageId []byte) (result *Tangle) {
 	result = &Tangle{
 		storageId:                  storageId,
-		transactionStorage:         objectstorage.New(badgerInstance, append(storageId, storageprefix.TangleTransaction...), transaction.FromStorage, objectstorage.CacheTime(10*time.Second), objectstorage.LeakDetectionEnabled(false)),
+		transactionStorage:         objectstorage.New(badgerInstance, append(storageId, storageprefix.TangleTransaction...), message.FromStorage, objectstorage.CacheTime(10*time.Second), objectstorage.LeakDetectionEnabled(false)),
 		transactionMetadataStorage: objectstorage.New(badgerInstance, append(storageId, storageprefix.TangleTransactionMetadata...), transactionmetadata.FromStorage, objectstorage.CacheTime(10*time.Second), objectstorage.LeakDetectionEnabled(false)),
-		approverStorage:            objectstorage.New(badgerInstance, append(storageId, storageprefix.TangleApprovers...), approver.FromStorage, objectstorage.CacheTime(10*time.Second), objectstorage.PartitionKey(transaction.IdLength, transaction.IdLength), objectstorage.LeakDetectionEnabled(false)),
+		approverStorage:            objectstorage.New(badgerInstance, append(storageId, storageprefix.TangleApprovers...), approver.FromStorage, objectstorage.CacheTime(10*time.Second), objectstorage.PartitionKey(message.IdLength, message.IdLength), objectstorage.LeakDetectionEnabled(false)),
 		missingTransactionsStorage: objectstorage.New(badgerInstance, append(storageId, storageprefix.TangleMissingTransaction...), missingtransaction.FromStorage, objectstorage.CacheTime(10*time.Second), objectstorage.LeakDetectionEnabled(false)),
 
 		Events: *newEvents(),
@@ -60,22 +60,22 @@ func (tangle *Tangle) GetStorageId() []byte {
 }
 
 // Attaches a new transaction to the tangle.
-func (tangle *Tangle) AttachTransaction(transaction *transaction.Transaction) {
+func (tangle *Tangle) AttachTransaction(transaction *message.Transaction) {
 	tangle.storeTransactionsWorkerPool.Submit(func() { tangle.storeTransactionWorker(transaction) })
 }
 
 // Retrieves a transaction from the tangle.
-func (tangle *Tangle) GetTransaction(transactionId transaction.Id) *transaction.CachedTransaction {
-	return &transaction.CachedTransaction{CachedObject: tangle.transactionStorage.Load(transactionId[:])}
+func (tangle *Tangle) GetTransaction(transactionId message.Id) *message.CachedTransaction {
+	return &message.CachedTransaction{CachedObject: tangle.transactionStorage.Load(transactionId[:])}
 }
 
 // Retrieves the metadata of a transaction from the tangle.
-func (tangle *Tangle) GetTransactionMetadata(transactionId transaction.Id) *transactionmetadata.CachedTransactionMetadata {
+func (tangle *Tangle) GetTransactionMetadata(transactionId message.Id) *transactionmetadata.CachedTransactionMetadata {
 	return &transactionmetadata.CachedTransactionMetadata{CachedObject: tangle.transactionMetadataStorage.Load(transactionId[:])}
 }
 
 // GetApprovers retrieves the approvers of a transaction from the tangle.
-func (tangle *Tangle) GetApprovers(transactionId transaction.Id) approver.CachedApprovers {
+func (tangle *Tangle) GetApprovers(transactionId message.Id) approver.CachedApprovers {
 	approvers := make(approver.CachedApprovers, 0)
 	tangle.approverStorage.ForEach(func(key []byte, cachedObject objectstorage.CachedObject) bool {
 		approvers = append(approvers, &approver.CachedApprover{CachedObject: cachedObject})
@@ -87,8 +87,8 @@ func (tangle *Tangle) GetApprovers(transactionId transaction.Id) approver.Cached
 }
 
 // Deletes a transaction from the tangle (i.e. for local snapshots)
-func (tangle *Tangle) DeleteTransaction(transactionId transaction.Id) {
-	tangle.GetTransaction(transactionId).Consume(func(currentTransaction *transaction.Transaction) {
+func (tangle *Tangle) DeleteTransaction(transactionId message.Id) {
+	tangle.GetTransaction(transactionId).Consume(func(currentTransaction *message.Transaction) {
 		trunkTransactionId := currentTransaction.GetTrunkTransactionId()
 		tangle.deleteApprover(trunkTransactionId, transactionId)
 
@@ -135,13 +135,13 @@ func (tangle *Tangle) Prune() error {
 }
 
 // Worker that stores the transactions and calls the corresponding storage events"
-func (tangle *Tangle) storeTransactionWorker(tx *transaction.Transaction) {
+func (tangle *Tangle) storeTransactionWorker(tx *message.Transaction) {
 	// store transaction
-	var cachedTransaction *transaction.CachedTransaction
+	var cachedTransaction *message.CachedTransaction
 	if _tmp, transactionIsNew := tangle.transactionStorage.StoreIfAbsent(tx); !transactionIsNew {
 		return
 	} else {
-		cachedTransaction = &transaction.CachedTransaction{CachedObject: _tmp}
+		cachedTransaction = &message.CachedTransaction{CachedObject: _tmp}
 	}
 
 	// store transaction metadata
@@ -170,9 +170,9 @@ func (tangle *Tangle) storeTransactionWorker(tx *transaction.Transaction) {
 }
 
 // Worker that solidifies the transactions (recursively from past to present).
-func (tangle *Tangle) solidifyTransactionWorker(cachedTransaction *transaction.CachedTransaction, cachedTransactionMetadata *transactionmetadata.CachedTransactionMetadata) {
-	isTransactionMarkedAsSolid := func(transactionId transaction.Id) bool {
-		if transactionId == transaction.EmptyId {
+func (tangle *Tangle) solidifyTransactionWorker(cachedTransaction *message.CachedTransaction, cachedTransactionMetadata *transactionmetadata.CachedTransactionMetadata) {
+	isTransactionMarkedAsSolid := func(transactionId message.Id) bool {
+		if transactionId == message.EmptyId {
 			return true
 		}
 
@@ -198,7 +198,7 @@ func (tangle *Tangle) solidifyTransactionWorker(cachedTransaction *transaction.C
 		return true
 	}
 
-	isTransactionSolid := func(transaction *transaction.Transaction, transactionMetadata *transactionmetadata.TransactionMetadata) bool {
+	isTransactionSolid := func(transaction *message.Transaction, transactionMetadata *transactionmetadata.TransactionMetadata) bool {
 		if transaction == nil || transaction.IsDeleted() {
 			return false
 		}
@@ -214,13 +214,13 @@ func (tangle *Tangle) solidifyTransactionWorker(cachedTransaction *transaction.C
 		return isTransactionMarkedAsSolid(transaction.GetTrunkTransactionId()) && isTransactionMarkedAsSolid(transaction.GetBranchTransactionId())
 	}
 
-	popElementsFromStack := func(stack *list.List) (*transaction.CachedTransaction, *transactionmetadata.CachedTransactionMetadata) {
+	popElementsFromStack := func(stack *list.List) (*message.CachedTransaction, *transactionmetadata.CachedTransactionMetadata) {
 		currentSolidificationEntry := stack.Front()
 		currentCachedTransaction := currentSolidificationEntry.Value.([2]interface{})[0]
 		currentCachedTransactionMetadata := currentSolidificationEntry.Value.([2]interface{})[1]
 		stack.Remove(currentSolidificationEntry)
 
-		return currentCachedTransaction.(*transaction.CachedTransaction), currentCachedTransactionMetadata.(*transactionmetadata.CachedTransactionMetadata)
+		return currentCachedTransaction.(*message.CachedTransaction), currentCachedTransactionMetadata.(*transactionmetadata.CachedTransactionMetadata)
 	}
 
 	// initialize the stack
@@ -261,9 +261,9 @@ func (tangle *Tangle) solidifyTransactionWorker(cachedTransaction *transaction.C
 }
 
 // Worker that Monitors the missing transactions (by scheduling regular checks).
-func (tangle *Tangle) monitorMissingTransactionWorker(transactionId transaction.Id) {
-	var scheduleNextMissingCheck func(transactionId transaction.Id)
-	scheduleNextMissingCheck = func(transactionId transaction.Id) {
+func (tangle *Tangle) monitorMissingTransactionWorker(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)
@@ -288,24 +288,24 @@ func (tangle *Tangle) monitorMissingTransactionWorker(transactionId transaction.
 	scheduleNextMissingCheck(transactionId)
 }
 
-func (tangle *Tangle) deleteApprover(approvedTransaction transaction.Id, approvingTransaction transaction.Id) {
-	idToDelete := make([]byte, transaction.IdLength+transaction.IdLength)
-	copy(idToDelete[:transaction.IdLength], approvedTransaction[:])
-	copy(idToDelete[transaction.IdLength:], approvingTransaction[:])
+func (tangle *Tangle) deleteApprover(approvedTransaction message.Id, approvingTransaction message.Id) {
+	idToDelete := make([]byte, message.IdLength+message.IdLength)
+	copy(idToDelete[:message.IdLength], approvedTransaction[:])
+	copy(idToDelete[message.IdLength:], approvingTransaction[:])
 	tangle.approverStorage.Delete(idToDelete)
 }
 
 // Deletes a transaction and all of its approvers (recursively).
-func (tangle *Tangle) deleteSubtangle(transactionId transaction.Id) {
+func (tangle *Tangle) deleteSubtangle(transactionId message.Id) {
 	cleanupStack := list.New()
 	cleanupStack.PushBack(transactionId)
 
-	processedTransactions := make(map[transaction.Id]types.Empty)
+	processedTransactions := make(map[message.Id]types.Empty)
 	processedTransactions[transactionId] = types.Void
 
 	for cleanupStack.Len() >= 1 {
 		currentStackEntry := cleanupStack.Front()
-		currentTransactionId := currentStackEntry.Value.(transaction.Id)
+		currentTransactionId := currentStackEntry.Value.(message.Id)
 		cleanupStack.Remove(currentStackEntry)
 
 		tangle.DeleteTransaction(currentTransactionId)

packages/binary/tangle/tangle_test.go

@@ -11,8 +11,8 @@ import (
 	"github.com/stretchr/testify/require"
 
 	"github.com/iotaledger/goshimmer/packages/binary/signature/ed25119"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transaction"
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transaction/payload/data"
+	"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,9 +34,9 @@ func BenchmarkTangle_AttachTransaction(b *testing.B) {
 
 	testIdentity := ed25119.GenerateKeyPair()
 
-	transactionBytes := make([]*transaction.Transaction, b.N)
+	transactionBytes := make([]*message.Transaction, b.N)
 	for i := 0; i < b.N; i++ {
-		transactionBytes[i] = transaction.New(transaction.EmptyId, transaction.EmptyId, testIdentity, time.Now(), 0, data.New([]byte("some data")))
+		transactionBytes[i] = message.New(message.EmptyId, message.EmptyId, testIdentity, time.Now(), 0, data.New([]byte("some data")))
 		transactionBytes[i].Bytes()
 	}
 
@@ -63,36 +63,36 @@ func TestTangle_AttachTransaction(t *testing.T) {
 		return
 	}
 
-	tangle.Events.TransactionAttached.Attach(events.NewClosure(func(cachedTransaction *transaction.CachedTransaction, cachedTransactionMetadata *transactionmetadata.CachedTransactionMetadata) {
+	tangle.Events.TransactionAttached.Attach(events.NewClosure(func(cachedTransaction *message.CachedTransaction, cachedTransactionMetadata *transactionmetadata.CachedTransactionMetadata) {
 		cachedTransactionMetadata.Release()
 
-		cachedTransaction.Consume(func(transaction *transaction.Transaction) {
+		cachedTransaction.Consume(func(transaction *message.Transaction) {
 			fmt.Println("ATTACHED:", transaction.GetId())
 		})
 	}))
 
-	tangle.Events.TransactionSolid.Attach(events.NewClosure(func(cachedTransaction *transaction.CachedTransaction, cachedTransactionMetadata *transactionmetadata.CachedTransactionMetadata) {
+	tangle.Events.TransactionSolid.Attach(events.NewClosure(func(cachedTransaction *message.CachedTransaction, cachedTransactionMetadata *transactionmetadata.CachedTransactionMetadata) {
 		cachedTransactionMetadata.Release()
 
-		cachedTransaction.Consume(func(transaction *transaction.Transaction) {
+		cachedTransaction.Consume(func(transaction *message.Transaction) {
 			fmt.Println("SOLID:", transaction.GetId())
 		})
 	}))
 
-	tangle.Events.TransactionUnsolidifiable.Attach(events.NewClosure(func(transactionId transaction.Id) {
+	tangle.Events.TransactionUnsolidifiable.Attach(events.NewClosure(func(transactionId message.Id) {
 		fmt.Println("UNSOLIDIFIABLE:", transactionId)
 	}))
 
-	tangle.Events.TransactionMissing.Attach(events.NewClosure(func(transactionId transaction.Id) {
+	tangle.Events.TransactionMissing.Attach(events.NewClosure(func(transactionId message.Id) {
 		fmt.Println("MISSING:", transactionId)
 	}))
 
-	tangle.Events.TransactionRemoved.Attach(events.NewClosure(func(transactionId transaction.Id) {
+	tangle.Events.TransactionRemoved.Attach(events.NewClosure(func(transactionId message.Id) {
 		fmt.Println("REMOVED:", transactionId)
 	}))
 
-	newTransaction1 := transaction.New(transaction.EmptyId, transaction.EmptyId, ed25119.GenerateKeyPair(), time.Now(), 0, data.New([]byte("some data")))
-	newTransaction2 := transaction.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, data.New([]byte("some data")))
+	newTransaction2 := message.New(newTransaction1.GetId(), newTransaction1.GetId(), ed25119.GenerateKeyPair(), time.Now(), 0, data.New([]byte("some other data")))
 
 	tangle.AttachTransaction(newTransaction2)
 

packages/binary/tangle/tipselector/events.go

 package tipselector
 
 import (
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/transaction"
+	"github.com/iotaledger/goshimmer/packages/binary/tangle/model/message"
 	"github.com/iotaledger/hive.go/events"
 )
 
@@ -11,5 +11,5 @@ type Events struct {
 }
 
 func transactionIdEvent(handler interface{}, params ...interface{}) {
-	handler.(func(transaction.Id))(params[0].(transaction.Id))
+	handler.(func(message.Id))(params[0].(message.Id))
 }