Feat: added solidification login

go.mod

@@ -15,7 +15,7 @@ require (
 	github.com/golang/protobuf v1.3.2 // indirect
 	github.com/google/open-location-code/go v0.0.0-20190903173953-119bc96a3a51
 	github.com/gorilla/websocket v1.4.1
-	github.com/iotaledger/hive.go v0.0.0-20200101211541-ea7950f4c2f2
+	github.com/iotaledger/hive.go v0.0.0-20200106003337-d78637b86bf2
 	github.com/iotaledger/iota.go v1.0.0-beta.9
 	github.com/kr/text v0.1.0
 	github.com/labstack/echo v3.3.10+incompatible

go.sum

@@ -101,6 +101,10 @@ github.com/iotaledger/hive.go v0.0.0-20200101185538-ae70241fee7f h1:vxfLVJOsHHEb
 github.com/iotaledger/hive.go v0.0.0-20200101185538-ae70241fee7f/go.mod h1:vrZrvGaWT1o5kz3Jj2B/PcUtqsFzZnLWrO3zEsGSuwk=
 github.com/iotaledger/hive.go v0.0.0-20200101211541-ea7950f4c2f2 h1:S84ohGcHKq6NFOY77HUXLvqYfOveJhzzphSeimTUtTw=
 github.com/iotaledger/hive.go v0.0.0-20200101211541-ea7950f4c2f2/go.mod h1:vrZrvGaWT1o5kz3Jj2B/PcUtqsFzZnLWrO3zEsGSuwk=
+github.com/iotaledger/hive.go v0.0.0-20200105155739-b36b4405762f h1:HqEFrjhbUB4uAOl9a9tTj78hYZ2bQLP9qLUlYwanPPY=
+github.com/iotaledger/hive.go v0.0.0-20200105155739-b36b4405762f/go.mod h1:vrZrvGaWT1o5kz3Jj2B/PcUtqsFzZnLWrO3zEsGSuwk=
+github.com/iotaledger/hive.go v0.0.0-20200106003337-d78637b86bf2 h1:HBQKEP6PnaEhG7j3HNjZTkpALvek8QYPeoJXyDzBDpo=
+github.com/iotaledger/hive.go v0.0.0-20200106003337-d78637b86bf2/go.mod h1:vrZrvGaWT1o5kz3Jj2B/PcUtqsFzZnLWrO3zEsGSuwk=
 github.com/iotaledger/iota.go v1.0.0-beta.9 h1:c654s9pkdhMBkABUvWg+6k91MEBbdtmZXP1xDfQpajg=
 github.com/iotaledger/iota.go v1.0.0-beta.9/go.mod h1:F6WBmYd98mVjAmmPVYhnxg8NNIWCjjH8VWT9qvv3Rc8=
 github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=

packages/binary/tangle/approvers/cached_approvers.go

+package approvers
+
+import (
+	"github.com/iotaledger/hive.go/objectstorage"
+)
+
+type CachedApprovers struct {
+	*objectstorage.CachedObject
+}
+
+func (cachedObject *CachedApprovers) Unwrap() *Approvers {
+	if untypedObject := cachedObject.Get(); untypedObject == nil {
+		return nil
+	} else {
+		if typedObject := untypedObject.(*Approvers); typedObject == nil || typedObject.IsDeleted() {
+			return nil
+		} else {
+			return typedObject
+		}
+	}
+}

packages/binary/tangle/missingtransaction/cached_missingtransaction.go

+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
+		}
+	}
+}

packages/binary/tangle/missingtransaction/missingtransaction.go

+package missingtransaction
+
+import (
+	"time"
+
+	"github.com/iotaledger/goshimmer/packages/binary/transaction"
+
+	"github.com/iotaledger/hive.go/objectstorage"
+)
+
+type MissingTransaction struct {
+	objectstorage.StorableObjectFlags
+	storageKey []byte
+
+	id           transaction.Id
+	missingSince time.Time
+}
+
+func New(id transaction.Id) *MissingTransaction {
+	return &MissingTransaction{
+		storageKey:   id[:],
+		id:           id,
+		missingSince: time.Now(),
+	}
+}
+
+func FromStorage(key []byte) objectstorage.StorableObject {
+	result := &MissingTransaction{
+		storageKey: make([]byte, len(key)),
+	}
+	copy(result.storageKey, key)
+
+	return result
+}
+
+func (missingTransaction *MissingTransaction) GetId() transaction.Id {
+	return missingTransaction.id
+}
+
+func (missingTransaction *MissingTransaction) GetMissingSince() time.Time {
+	return missingTransaction.missingSince
+}
+
+func (missingTransaction *MissingTransaction) GetStorageKey() []byte {
+	return missingTransaction.storageKey
+}
+
+func (missingTransaction *MissingTransaction) Update(other objectstorage.StorableObject) {
+	panic("missing transactions should never be overwritten and only stored once to optimize IO")
+}
+
+func (missingTransaction *MissingTransaction) MarshalBinary() (result []byte, err error) {
+	return missingTransaction.missingSince.MarshalBinary()
+}
+
+func (missingTransaction *MissingTransaction) UnmarshalBinary(data []byte) (err error) {
+	copy(missingTransaction.id[:], missingTransaction.storageKey)
+
+	return missingTransaction.missingSince.UnmarshalBinary(data)
+}

packages/binary/tangle/solidifier.go

-package tangle
-
-import (
-	"container/list"
-
-	"github.com/iotaledger/goshimmer/packages/binary/tangle/approvers"
-	"github.com/iotaledger/goshimmer/packages/binary/transaction"
-	"github.com/iotaledger/goshimmer/packages/binary/transactionmetadata"
-	"github.com/iotaledger/hive.go/async"
-	"github.com/iotaledger/hive.go/objectstorage"
-)
-
-type solidifier struct {
-	tangle *Tangle
-
-	workerPool async.WorkerPool
-}
-
-func newSolidifier(tangle *Tangle) (result *solidifier) {
-	result = &solidifier{
-		tangle: tangle,
-	}
-
-	result.workerPool.Tune(1024)
-
-	return
-}
-
-func (solidifier *solidifier) Shutdown() {
-	solidifier.workerPool.ShutdownGracefully()
-}
-
-func (solidifier *solidifier) Solidify(cachedTransaction *objectstorage.CachedObject, cachedTransactionMetadata *objectstorage.CachedObject) {
-	solidifier.workerPool.Submit(func() { solidifier.solidify(cachedTransaction, cachedTransactionMetadata) })
-}
-
-func (solidifier *solidifier) solidify(cachedTransaction *objectstorage.CachedObject, cachedTransactionMetadata *objectstorage.CachedObject) {
-	// initialize the stack
-	solidificationStack := list.New()
-	solidificationStack.PushBack([2]*objectstorage.CachedObject{cachedTransaction, cachedTransactionMetadata})
-
-	// process transactions that are supposed to be checked for solidity recursively
-	for solidificationStack.Len() > 0 {
-		// pop first element from stack
-		currentSolidificationEntry := solidificationStack.Front()
-		currentCachedTransaction := currentSolidificationEntry.Value.([2]*objectstorage.CachedObject)[0]
-		currentCachedTransactionMetadata := currentSolidificationEntry.Value.([2]*objectstorage.CachedObject)[1]
-		solidificationStack.Remove(currentSolidificationEntry)
-
-		// retrieve transaction from cached result
-		var currentTransaction *transaction.Transaction
-		if _tmp := currentCachedTransaction.Get(); _tmp != nil {
-			currentTransaction = _tmp.(*transaction.Transaction)
-		} else {
-			currentCachedTransaction.Release()
-			currentCachedTransactionMetadata.Release()
-
-			continue
-		}
-
-		// retrieve metadata from cached result
-		var currentTransactionMetadata *transactionmetadata.TransactionMetadata
-		if _tmp := currentCachedTransactionMetadata.Get(); _tmp != nil {
-			currentTransactionMetadata = _tmp.(*transactionmetadata.TransactionMetadata)
-		} else {
-			currentCachedTransaction.Release()
-			currentCachedTransactionMetadata.Release()
-
-			continue
-		}
-
-		// if current transaction is solid and was not marked as solid before: mark as solid and propagate
-		if solidifier.isTransactionSolid(currentTransaction, currentTransactionMetadata) && currentTransactionMetadata.SetSolid(true) {
-			solidifier.tangle.Events.TransactionSolid.Trigger(currentCachedTransaction, currentCachedTransactionMetadata)
-
-			solidifier.tangle.GetApprovers(currentTransaction.GetId()).Consume(func(object objectstorage.StorableObject) {
-				for approverTransactionId := range object.(*approvers.Approvers).Get() {
-					solidificationStack.PushBack([2]*objectstorage.CachedObject{
-						solidifier.tangle.GetTransaction(approverTransactionId),
-						solidifier.tangle.GetTransactionMetadata(approverTransactionId),
-					})
-				}
-			})
-		}
-
-		// release cached results
-		currentCachedTransaction.Release()
-		currentCachedTransactionMetadata.Release()
-	}
-}
-
-func (solidifier *solidifier) isTransactionSolid(transaction *transaction.Transaction, transactionMetadata *transactionmetadata.TransactionMetadata) bool {
-	if transaction == nil || transaction.IsDeleted() {
-		return false
-	}
-
-	if transactionMetadata == nil || transactionMetadata.IsDeleted() {
-		return false
-	}
-
-	if transactionMetadata.IsSolid() {
-		return true
-	}
-
-	// 1. check tangle solidity
-	if solidifier.isTransactionSolidInTangle(transaction.GetTrunkTransactionId()) && solidifier.isTransactionSolidInTangle(transaction.GetBranchTransactionId()) {
-		// 2. check payload solidity
-		return true
-	}
-
-	return false
-}
-
-func (solidifier *solidifier) isTransactionSolidInTangle(transactionId transaction.Id) bool {
-	if transactionId != transaction.EmptyId {
-		cachedTransactionMetadata := solidifier.tangle.GetTransactionMetadata(transactionId)
-
-		if transactionMetadata := cachedTransactionMetadata.Get().(*transactionmetadata.TransactionMetadata); transactionMetadata == nil || transactionMetadata.IsDeleted() || !transactionMetadata.IsSolid() {
-			cachedTransactionMetadata.Release()
-
-			return false
-		}
-
-		cachedTransactionMetadata.Release()
-	}
-
-	return true
-}

packages/binary/tangle/tangle.go

 package tangle
 
 import (
+	"container/list"
+	"fmt"
+
 	"github.com/iotaledger/goshimmer/packages/binary/tangle/approvers"
+	"github.com/iotaledger/goshimmer/packages/binary/tangle/missingtransaction"
 	"github.com/iotaledger/goshimmer/packages/binary/transaction"
 	"github.com/iotaledger/goshimmer/packages/binary/transactionmetadata"
 	"github.com/iotaledger/goshimmer/packages/storageprefix"
-	"github.com/iotaledger/goshimmer/packages/stringify"
 	"github.com/iotaledger/hive.go/async"
 	"github.com/iotaledger/hive.go/events"
 	"github.com/iotaledger/hive.go/objectstorage"
-	"github.com/pkg/errors"
 )
 
 type Tangle struct {
-	solidifier                 *solidifier
 	transactionStorage         *objectstorage.ObjectStorage
 	transactionMetadataStorage *objectstorage.ObjectStorage
 	approversStorage           *objectstorage.ObjectStorage
+	missingTransactionsStorage *objectstorage.ObjectStorage
 
 	Events tangleEvents
 
-	verifyTransactionsWorkerPool async.WorkerPool
-	storeTransactionsWorkerPool  async.WorkerPool
+	storeTransactionsWorkerPool async.WorkerPool
+	solidifierWorkerPool        async.WorkerPool
 }
 
 func New(storageId []byte) (result *Tangle) {
@@ -29,25 +31,26 @@ func New(storageId []byte) (result *Tangle) {
 		transactionStorage:         objectstorage.New(append(storageId, storageprefix.TangleTransaction...), transactionFactory),
 		transactionMetadataStorage: objectstorage.New(append(storageId, storageprefix.TangleTransactionMetadata...), transactionFactory),
 		approversStorage:           objectstorage.New(append(storageId, storageprefix.TangleApprovers...), approversFactory),
+		missingTransactionsStorage: objectstorage.New(append(storageId, storageprefix.TangleTransaction...), missingtransaction.FromStorage),
 
 		Events: tangleEvents{
 			TransactionAttached: events.NewEvent(func(handler interface{}, params ...interface{}) {
-				cachedTransaction := params[0].(*objectstorage.CachedObject)
-				cachedTransactionMetadata := params[1].(*objectstorage.CachedObject)
+				cachedTransaction := params[0].(*transaction.CachedTransaction)
+				cachedTransactionMetadata := params[1].(*transactionmetadata.CachedTransactionMetadata)
 
 				cachedTransaction.RegisterConsumer()
 				cachedTransactionMetadata.RegisterConsumer()
 
-				handler.(func(*objectstorage.CachedObject, *objectstorage.CachedObject))(cachedTransaction, cachedTransactionMetadata)
+				handler.(func(*transaction.CachedTransaction, *transactionmetadata.CachedTransactionMetadata))(cachedTransaction, cachedTransactionMetadata)
 			}),
 			TransactionSolid: events.NewEvent(func(handler interface{}, params ...interface{}) {
-				cachedTransaction := params[0].(*objectstorage.CachedObject)
-				cachedTransactionMetadata := params[1].(*objectstorage.CachedObject)
+				cachedTransaction := params[0].(*transaction.CachedTransaction)
+				cachedTransactionMetadata := params[1].(*transactionmetadata.CachedTransactionMetadata)
 
 				cachedTransaction.RegisterConsumer()
 				cachedTransactionMetadata.RegisterConsumer()
 
-				handler.(func(*objectstorage.CachedObject, *objectstorage.CachedObject))(cachedTransaction, cachedTransactionMetadata)
+				handler.(func(*transaction.CachedTransaction, *transactionmetadata.CachedTransactionMetadata))(cachedTransaction, cachedTransactionMetadata)
 			}),
 			Error: events.NewEvent(func(handler interface{}, params ...interface{}) {
 				handler.(func(error))(params[0].(error))
@@ -55,7 +58,7 @@ func New(storageId []byte) (result *Tangle) {
 		},
 	}
 
-	result.solidifier = newSolidifier(result)
+	result.solidifierWorkerPool.Tune(1024)
 
 	return
 }
@@ -77,60 +80,159 @@ func (tangle *Tangle) Prune() error {
 }
 
 func (tangle *Tangle) AttachTransaction(transaction *transaction.Transaction) {
-	tangle.verifyTransactionsWorkerPool.Submit(func() { tangle.verifyTransaction(transaction) })
+	tangle.storeTransactionsWorkerPool.Submit(func() { tangle.storeTransaction(transaction) })
 }
 
-func (tangle *Tangle) GetTransaction(transactionId transaction.Id) *objectstorage.CachedObject {
-	return tangle.transactionStorage.Load(transactionId[:])
+func (tangle *Tangle) GetTransaction(transactionId transaction.Id) *transaction.CachedTransaction {
+	return &transaction.CachedTransaction{CachedObject: tangle.transactionStorage.Load(transactionId[:])}
 }
 
-func (tangle *Tangle) GetTransactionMetadata(transactionId transaction.Id) *objectstorage.CachedObject {
-	return tangle.transactionMetadataStorage.Load(transactionId[:])
+func (tangle *Tangle) GetTransactionMetadata(transactionId transaction.Id) *transactionmetadata.CachedTransactionMetadata {
+	return &transactionmetadata.CachedTransactionMetadata{CachedObject: tangle.transactionMetadataStorage.Load(transactionId[:])}
 }
 
-func (tangle *Tangle) GetApprovers(transactionId transaction.Id) *objectstorage.CachedObject {
-	return tangle.approversStorage.Load(transactionId[:])
+func (tangle *Tangle) GetApprovers(transactionId transaction.Id) *approvers.CachedApprovers {
+	return &approvers.CachedApprovers{CachedObject: tangle.approversStorage.Load(transactionId[:])}
 }
 
-func (tangle *Tangle) verifyTransaction(transaction *transaction.Transaction) {
-	if !transaction.VerifySignature() {
-		tangle.Events.Error.Trigger(errors.New("transaction with id " + stringify.Interface(transaction.GetId()) + " has an invalid signature"))
+// Marks the tangle as stopped, so it will not accept any new transactions, and then waits for all backgroundTasks to
+// finish.
+func (tangle *Tangle) Shutdown() *Tangle {
+	tangle.storeTransactionsWorkerPool.ShutdownGracefully()
+	tangle.solidifierWorkerPool.ShutdownGracefully()
+
+	return tangle
+}
 
+func (tangle *Tangle) storeTransaction(tx *transaction.Transaction) {
+	cachedTransaction, transactionIsNew := tangle.transactionStorage.StoreIfAbsent(tx.GetStorageKey(), tx)
+	if !transactionIsNew {
 		return
 	}
 
-	tangle.storeTransactionsWorkerPool.Submit(func() { tangle.storeTransaction(transaction) })
+	cachedTransactionMetadata := tangle.createTransactionMetadata(tx)
+	tangle.addTransactionToApprovers(tx, tx.GetTrunkTransactionId())
+	tangle.addTransactionToApprovers(tx, tx.GetBranchTransactionId())
+
+	transactionId := tx.GetId()
+	if tangle.missingTransactionsStorage.DeleteIfPresent(transactionId[:]) {
+		fmt.Println("MISSING TRANSACTION RECEIVED")
+	}
+
+	tangle.solidifierWorkerPool.Submit(func() {
+		tangle.solidify(&transaction.CachedTransaction{CachedObject: cachedTransaction}, cachedTransactionMetadata)
+	})
 }
 
-func (tangle *Tangle) storeTransaction(transaction *transaction.Transaction) {
-	cachedTransaction, transactionIsNew := tangle.transactionStorage.StoreIfAbsent(transaction.GetStorageKey(), transaction)
-	if !transactionIsNew {
-		return
+// Payloads can have different solidification rules and it might happen, that an external process needs to "manually
+// trigger" the solidification checks of a transaction (to update it's solidification status).
+func (tangle *Tangle) Solidify(transactionId transaction.Id) {
+	tangle.solidifierWorkerPool.Submit(func() {
+		tangle.solidify(tangle.GetTransaction(transactionId), tangle.GetTransactionMetadata(transactionId))
+	})
+}
+
+func (tangle *Tangle) solidify(cachedTransaction *transaction.CachedTransaction, cachedTransactionMetadata *transactionmetadata.CachedTransactionMetadata) {
+	popElementsFromStack := func(stack *list.List) (*transaction.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)
+	}
+
+	// initialize the stack
+	solidificationStack := list.New()
+	solidificationStack.PushBack([2]interface{}{cachedTransaction, cachedTransactionMetadata})
+
+	// process transactions that are supposed to be checked for solidity recursively
+	for solidificationStack.Len() > 0 {
+		currentCachedTransaction, currentCachedTransactionMetadata := popElementsFromStack(solidificationStack)
+
+		currentTransaction := currentCachedTransaction.Unwrap()
+		currentTransactionMetadata := currentCachedTransactionMetadata.Unwrap()
+		if currentTransaction == nil || currentTransactionMetadata == nil {
+			currentCachedTransaction.Release()
+			currentCachedTransactionMetadata.Release()
+
+			continue
+		}
+
+		// if current transaction is solid and was not marked as solid before: mark as solid and propagate
+		if tangle.isTransactionSolid(currentTransaction, currentTransactionMetadata) && currentTransactionMetadata.SetSolid(true) {
+			tangle.Events.TransactionSolid.Trigger(currentCachedTransaction, currentCachedTransactionMetadata)
+
+			tangle.GetApprovers(currentTransaction.GetId()).Consume(func(object objectstorage.StorableObject) {
+				for approverTransactionId := range object.(*approvers.Approvers).Get() {
+					solidificationStack.PushBack([2]interface{}{
+						tangle.GetTransaction(approverTransactionId),
+						tangle.GetTransactionMetadata(approverTransactionId),
+					})
+				}
+			})
+		}
+
+		// release cached results
+		currentCachedTransaction.Release()
+		currentCachedTransactionMetadata.Release()
+	}
+}
+
+func (tangle *Tangle) isTransactionSolid(transaction *transaction.Transaction, transactionMetadata *transactionmetadata.TransactionMetadata) bool {
+	if transaction == nil || transaction.IsDeleted() {
+		return false
 	}
 
-	cachedTransactionMetadata := tangle.createTransactionMetadata(transaction)
+	if transactionMetadata == nil || transactionMetadata.IsDeleted() {
+		return false
+	}
 
-	tangle.addTransactionToApprovers(transaction, transaction.GetTrunkTransactionId())
-	tangle.addTransactionToApprovers(transaction, transaction.GetBranchTransactionId())
+	if transactionMetadata.IsSolid() {
+		return true
+	}
+
+	// 1. check tangle solidity
+	isTrunkSolid := tangle.isTransactionMarkedAsSolid(transaction.GetTrunkTransactionId())
+	isBranchSolid := tangle.isTransactionMarkedAsSolid(transaction.GetBranchTransactionId())
+	if isTrunkSolid && isBranchSolid {
+		// 2. check payload solidity
+		return true
+	}
 
-	tangle.solidifier.Solidify(cachedTransaction, cachedTransactionMetadata)
+	return false
 }
 
-// Marks the tangle as stopped, so it will not accept any new transactions, and then waits for all backgroundTasks to
-// finish.
-func (tangle *Tangle) Shutdown() *Tangle {
-	tangle.verifyTransactionsWorkerPool.ShutdownGracefully()
-	tangle.storeTransactionsWorkerPool.ShutdownGracefully()
+func (tangle *Tangle) isTransactionMarkedAsSolid(transactionId transaction.Id) bool {
+	if transactionId == transaction.EmptyId {
+		return true
+	}
 
-	tangle.solidifier.Shutdown()
+	cachedTransactionMetadata := tangle.GetTransactionMetadata(transactionId)
+	if transactionMetadata := cachedTransactionMetadata.Unwrap(); transactionMetadata == nil {
+		cachedTransactionMetadata.Release()
 
-	return tangle
+		if _, missingTransactionStored := tangle.missingTransactionsStorage.StoreIfAbsent(transactionId[:], &missingtransaction.MissingTransaction{}); missingTransactionStored {
+			// Trigger
+			fmt.Println("MISSING TX EVENT")
+		}
+		// transaction is missing -> add to solidifier
+
+		return false
+	} else if !transactionMetadata.IsSolid() {
+		cachedTransactionMetadata.Release()
+
+		return false
+	}
+	cachedTransactionMetadata.Release()
+
+	return true
 }
 
-func (tangle *Tangle) createTransactionMetadata(transaction *transaction.Transaction) *objectstorage.CachedObject {
+func (tangle *Tangle) createTransactionMetadata(transaction *transaction.Transaction) *transactionmetadata.CachedTransactionMetadata {
 	transactionMetadata := transactionmetadata.New(transaction.GetId())
 
-	return tangle.transactionMetadataStorage.Store(transactionMetadata)
+	return &transactionmetadata.CachedTransactionMetadata{CachedObject: tangle.transactionMetadataStorage.Store(transactionMetadata)}
 }
 
 func (tangle *Tangle) addTransactionToApprovers(transaction *transaction.Transaction, trunkTransactionId transaction.Id) {

packages/binary/tangle/tangle_test.go

@@ -3,6 +3,7 @@ package tangle
 import (
 	"fmt"
 	"testing"
+	"time"
 
 	"github.com/iotaledger/goshimmer/packages/binary/identity"
 	"github.com/iotaledger/goshimmer/packages/binary/transaction"
@@ -48,11 +49,13 @@ func TestTangle_AttachTransaction(t *testing.T) {
 	}
 
 	newTransaction1 := transaction.New(transaction.EmptyId, transaction.EmptyId, identity.Generate(), data.New([]byte("some data")))
-	newTransaction2 := transaction.New(newTransaction1.GetId(), transaction.EmptyId, identity.Generate(), data.New([]byte("some other data")))
+	newTransaction2 := transaction.New(newTransaction1.GetId(), newTransaction1.GetId(), identity.Generate(), data.New([]byte("some other data")))
 
 	fmt.Println("ATTACH", newTransaction2.GetId())
 	tangle.AttachTransaction(newTransaction2)
 
+	time.Sleep(1 * time.Second)
+
 	fmt.Println("ATTACH", newTransaction1.GetId())
 	tangle.AttachTransaction(newTransaction1)
 

packages/binary/transaction/cached_transaction.go

+package transaction
+
+import (
+	"github.com/iotaledger/hive.go/objectstorage"
+)
+
+type CachedTransaction struct {
+	*objectstorage.CachedObject
+}
+
+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
+		}
+	}
+}

packages/binary/transactionmetadata/cached_transactionmetadata.go

+package transactionmetadata
+
+import (
+	"github.com/iotaledger/hive.go/objectstorage"
+)
+
+type CachedTransactionMetadata struct {
+	*objectstorage.CachedObject
+}
+
+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
+		}
+	}
+}

packages/binary/transactionparser/builtinfilters/value_transaction_signature_filter.go

@@ -9,7 +9,7 @@ import (
 	"github.com/iotaledger/hive.go/async"
 )
 
-type ValueTransactionSignatureFilter struct {
+type ValueTransferSignatureFilter struct {
 	onAcceptCallback func(tx *transaction.Transaction)
 	onRejectCallback func(tx *transaction.Transaction)
 	workerPool       async.WorkerPool
@@ -18,13 +18,13 @@ type ValueTransactionSignatureFilter struct {
 	onRejectCallbackMutex sync.RWMutex
 }
 
-func NewValueTransactionSignatureFilter() (result *ValueTransactionSignatureFilter) {
-	result = &ValueTransactionSignatureFilter{}
+func NewValueTransferSignatureFilter() (result *ValueTransferSignatureFilter) {
+	result = &ValueTransferSignatureFilter{}
 
 	return
 }
 
-func (filter *ValueTransactionSignatureFilter) Filter(tx *transaction.Transaction) {
+func (filter *ValueTransferSignatureFilter) Filter(tx *transaction.Transaction) {
 	filter.workerPool.Submit(func() {
 		if payload := tx.GetPayload(); payload.GetType() == valuetransfer.Type {
 			if valueTransfer, ok := payload.(*valuetransfer.ValueTransfer); ok && valueTransfer.VerifySignatures() {
@@ -38,23 +38,23 @@ func (filter *ValueTransactionSignatureFilter) Filter(tx *transaction.Transactio
 	})
 }
 
-func (filter *ValueTransactionSignatureFilter) OnAccept(callback func(tx *transaction.Transaction)) {
+func (filter *ValueTransferSignatureFilter) OnAccept(callback func(tx *transaction.Transaction)) {
 	filter.onAcceptCallbackMutex.Lock()
 	filter.onAcceptCallback = callback
 	filter.onAcceptCallbackMutex.Unlock()
 }
 
-func (filter *ValueTransactionSignatureFilter) OnReject(callback func(tx *transaction.Transaction)) {
+func (filter *ValueTransferSignatureFilter) OnReject(callback func(tx *transaction.Transaction)) {
 	filter.onRejectCallbackMutex.Lock()
 	filter.onRejectCallback = callback
 	filter.onRejectCallbackMutex.Unlock()
 }
 
-func (filter *ValueTransactionSignatureFilter) Shutdown() {
+func (filter *ValueTransferSignatureFilter) Shutdown() {
 	filter.workerPool.ShutdownGracefully()
 }
 
-func (filter *ValueTransactionSignatureFilter) getAcceptCallback() (result func(tx *transaction.Transaction)) {
+func (filter *ValueTransferSignatureFilter) getAcceptCallback() (result func(tx *transaction.Transaction)) {
 	filter.onAcceptCallbackMutex.RLock()
 	result = filter.onAcceptCallback
 	filter.onAcceptCallbackMutex.RUnlock()
@@ -62,7 +62,7 @@ func (filter *ValueTransactionSignatureFilter) getAcceptCallback() (result func(
 	return
 }
 
-func (filter *ValueTransactionSignatureFilter) getRejectCallback() (result func(tx *transaction.Transaction)) {
+func (filter *ValueTransferSignatureFilter) getRejectCallback() (result func(tx *transaction.Transaction)) {
 	filter.onRejectCallbackMutex.RLock()
 	result = filter.onRejectCallback
 	filter.onRejectCallbackMutex.RUnlock()

packages/binary/transactionparser/transactionparser.go

@@ -43,7 +43,7 @@ func New() (result *TransactionParser) {
 	// add builtin filters
 	result.AddBytesFilter(builtinfilters.NewRecentlySeenBytesFilter())
 	result.AddTransactionsFilter(builtinfilters.NewTransactionSignatureFilter())
-	result.AddTransactionsFilter(builtinfilters.NewValueTransactionSignatureFilter())
+	result.AddTransactionsFilter(builtinfilters.NewValueTransferSignatureFilter())
 
 	return
 }