Feat: started implementing confirmed propagation

dapps/valuetransfers/packages/branchmanager/branch.go

@@ -21,12 +21,14 @@ type Branch struct {
 	conflicts      map[ConflictID]types.Empty
 	preferred      bool
 	liked          bool
+	finalized      bool
 	confirmed      bool
 
 	parentBranchesMutex sync.RWMutex
 	conflictsMutex      sync.RWMutex
 	preferredMutex      sync.RWMutex
 	likedMutex          sync.RWMutex
+	finalizedMutex      sync.RWMutex
 	confirmedMutex      sync.RWMutex
 }
 
@@ -248,6 +250,41 @@ func (branch *Branch) setLiked(liked bool) (modified bool) {
 	return branch.liked
 }
 
+// Finalized returns true if the branch has been marked as finalized.
+func (branch *Branch) Finalized() bool {
+	branch.finalizedMutex.RLock()
+	defer branch.finalizedMutex.RUnlock()
+
+	return branch.finalized
+}
+
+// setFinalized is the setter for the finalized flag. It returns true if the value of the flag has been updated.
+// A branch is finalized if a decisions regarding its preference has been made.
+// Note: Just because a branch has been finalized, does not mean that all transactions it contains have also been
+//       finalized but only that the underlying conflict that created the Branch has been finalized.
+func (branch *Branch) setFinalized(finalized bool) (modified bool) {
+	branch.finalizedMutex.RLock()
+	if branch.finalized == finalized {
+		branch.finalizedMutex.RUnlock()
+
+		return
+	}
+
+	branch.finalizedMutex.RUnlock()
+	branch.finalizedMutex.Lock()
+	defer branch.finalizedMutex.Unlock()
+
+	if branch.finalized == finalized {
+		return
+	}
+
+	branch.finalized = finalized
+	branch.SetModified()
+	modified = true
+
+	return
+}
+
 // Confirmed returns true if the branch has been accepted to be part of the ledger state.
 func (branch *Branch) Confirmed() bool {
 	branch.confirmedMutex.RLock()

dapps/valuetransfers/packages/branchmanager/branchmanager.go

@@ -344,6 +344,10 @@ func (branchManager *BranchManager) SetBranchLiked(branchID BranchID, liked bool
 	return branchManager.setBranchLiked(branchManager.Branch(branchID), liked)
 }
 
+func (branchManager *BranchManager) SetBranchFinalized(branchID BranchID) (modified bool, err error) {
+	return
+}
+
 // Prune resets the database and deletes all objects (for testing or "node resets").
 func (branchManager *BranchManager) Prune() (err error) {
 	for _, storage := range []*objectstorage.ObjectStorage{

dapps/valuetransfers/packages/tangle/tangle.go

@@ -144,6 +144,32 @@ func (tangle *Tangle) AttachPayload(payload *payload.Payload) {
 	tangle.workerPool.Submit(func() { tangle.AttachPayloadSync(payload) })
 }
 
+func (tangle *Tangle) SetTransactionFinalized(transactionID transaction.ID) (modified bool, err error) {
+	tangle.TransactionMetadata(transactionID).Consume(func(metadata *TransactionMetadata) {
+		// only propagate the changes if the flag was modified
+		if modified = metadata.SetFinalized(true); modified {
+			// propagate changes to the branches (UTXO DAG)
+			if metadata.Conflicting() {
+				_, err = tangle.branchManager.SetBranchFinalized(metadata.BranchID())
+				if err != nil {
+					tangle.Events.Error.Trigger(err)
+
+					return
+				}
+			}
+
+			// propagate changes to future cone of transaction (value tangle)
+			tangle.propagateValuePayloadConfirmedUpdates(transactionID)
+		}
+	})
+
+	return
+}
+
+func (tangle *Tangle) propagateValuePayloadConfirmedUpdates(transactionID transaction.ID) {
+	return
+}
+
 // SetTransactionPreferred modifies the preferred flag of a transaction. It updates the transactions metadata and
 // propagates the changes to the BranchManager if the flag was updated.
 func (tangle *Tangle) SetTransactionPreferred(transactionID transaction.ID, preferred bool) (modified bool, err error) {