Feat: aggregatin aggregated realities is shown correctly

packages/ledgerstate/ledgerstate_test.go

@@ -152,32 +152,23 @@ func spend(ledgerState *LedgerState, transferOutputReferences ...*TransferOutput
 	transferHash := generateRandomTransferHash()
 	addressHash := generateRandomAddressHash()
 
-	transfer := NewTransfer(transferHash).AddOutput(
-		addressHash, NewColoredBalance(iota_, uint64(len(transferOutputReferences))*1337),
-	)
-	for _, transferOutputReference := range transferOutputReferences {
-		transfer.AddInput(transferOutputReference)
-	}
-
-	if err := ledgerState.BookTransfer(transfer); err != nil {
-		panic(err)
-	}
-
-	result = NewTransferOutputReference(transferHash, addressHash)
+	totalInputBalance := uint64(0)
 
-	return
-}
+	transfer := NewTransfer(transferHash)
+	for _, transferOutputReference := range transferOutputReferences {
+		ledgerState.GetTransferOutput(transferOutputReference).Consume(func(object objectstorage.StorableObject) {
+			transferOutput := object.(*TransferOutput)
 
-func spend2(ledgerState *LedgerState, transferOutputReferences ...*TransferOutputReference) (result *TransferOutputReference) {
-	transferHash := generateRandomTransferHash()
-	addressHash := generateRandomAddressHash()
+			for _, coloredBalance := range transferOutput.GetBalances() {
+				totalInputBalance += coloredBalance.GetValue()
+			}
+		})
 
-	transfer := NewTransfer(transferHash).AddOutput(
-		addressHash, NewColoredBalance(iota_, uint64(len(transferOutputReferences))*2*1337),
-	)
-	for _, transferOutputReference := range transferOutputReferences {
 		transfer.AddInput(transferOutputReference)
 	}
+	transfer.AddOutput(
+		addressHash, NewColoredBalance(iota_, totalInputBalance),
+	)
 
 	if err := ledgerState.BookTransfer(transfer); err != nil {
 		panic(err)
@@ -195,7 +186,7 @@ func TestElevateAggregatedReality(t *testing.T) {
 	doubleSpentOutputs1 := doubleSpend(ledgerState, transferOutputs[0])
 	doubleSpentOutputs2 := doubleSpend(ledgerState, transferOutputs[1])
 	normalSpend := spend(ledgerState, transferOutputs[2])
-	_ = doubleSpend(ledgerState, normalSpend)
+	doubleSpentOutputs3 := doubleSpend(ledgerState, normalSpend)
 
 	// send funds from one of the double spends further
 	spentInput := spend(ledgerState, doubleSpentOutputs1[1])
@@ -207,10 +198,13 @@ func TestElevateAggregatedReality(t *testing.T) {
 	spend(ledgerState, doubleSpentOutputs1[1])
 
 	// double spend funds of aggregated reality
-	spend(ledgerState, spentInput, doubleSpentOutputs2[0])
+	//spend(ledgerState, spentInput, doubleSpentOutputs2[0])
 
 	// spend funds of conflict in aggregated reality further
-	spend2(ledgerState, outputOfAggregatedReality)
+	//lastOutputOfAggregatedReality := spend(ledgerState, outputOfAggregatedReality)
+
+	//spend(ledgerState, lastOutputOfAggregatedReality, doubleSpentOutputs3[1])
+	spend(ledgerState, spend(ledgerState, spend(ledgerState, outputOfAggregatedReality, spend(ledgerState, doubleSpentOutputs3[1]))))
 
 	time.Sleep(1000 * time.Millisecond)
 

packages/ledgerstate/reality.go

@@ -127,6 +127,33 @@ func (reality *Reality) GetParentRealities() map[RealityId]*objectstorage.Cached
 	return parentRealities
 }
 
+// Returns
+func (reality *Reality) GetParentConflictRealities() map[RealityId]*objectstorage.CachedObject {
+	if !reality.IsAggregated() {
+		return reality.GetParentRealities()
+	} else {
+		parentConflictRealities := make(map[RealityId]*objectstorage.CachedObject)
+
+		reality.collectParentConflictRealities(parentConflictRealities)
+
+		return parentConflictRealities
+	}
+}
+
+func (reality *Reality) collectParentConflictRealities(parentConflictRealities map[RealityId]*objectstorage.CachedObject) {
+	for realityId, cachedParentReality := range reality.GetParentRealities() {
+		parentReality := cachedParentReality.Get().(*Reality)
+
+		if !parentReality.IsAggregated() {
+			parentConflictRealities[realityId] = cachedParentReality
+		} else {
+			parentReality.collectParentConflictRealities(parentConflictRealities)
+
+			cachedParentReality.Release()
+		}
+	}
+}
+
 // [DONE] Returns a map of all ancestor realities (up till the MAIN_REALITY). They have to manually be "released" when
 // they are not needed anymore.
 func (reality *Reality) GetAncestorRealities() (result map[RealityId]*objectstorage.CachedObject) {

packages/ledgerstate/visualizer.go

@@ -100,7 +100,7 @@ func (visualizer *Visualizer) getRealitySubGraph(realityId RealityId) *dot.Graph
 			parentRealities := reality.GetParentRealityIds()
 			switch true {
 			case len(parentRealities) > 1:
-				realityGraph = visualizer.getRealitySubGraph(MAIN_REALITY_ID).Subgraph(visualizer.generateRealityName(parentRealities.ToList()...), dot.ClusterOption{})
+				realityGraph = visualizer.getRealitySubGraph(MAIN_REALITY_ID).Subgraph("AGGREGATED REALITY [ "+visualizer.generateRealityName(realityId)+" ]", dot.ClusterOption{})
 
 				visualizer.styleRealitySubGraph(realityGraph, realityTypeAggregated)
 
@@ -112,7 +112,7 @@ func (visualizer *Visualizer) getRealitySubGraph(realityId RealityId) *dot.Graph
 				//dummyNode.Attr("width", "0")
 			case len(parentRealities) == 1:
 				for parentRealityId := range parentRealities {
-					realityGraph = visualizer.getRealitySubGraph(parentRealityId).Subgraph(visualizer.generateRealityName(realityId), dot.ClusterOption{})
+					realityGraph = visualizer.getRealitySubGraph(parentRealityId).Subgraph("REALITY [ "+visualizer.generateRealityName(realityId)+" ]", dot.ClusterOption{})
 
 					visualizer.styleRealitySubGraph(realityGraph, realityTypeDefault)
 				}
@@ -148,29 +148,31 @@ func (visualizer *Visualizer) styleRealitySubGraph(realitySubGraph *dot.Graph, r
 	}
 }
 
-func (visualizer *Visualizer) generateRealityName(realityIds ...RealityId) string {
-	if len(realityIds) > 1 {
-		result := "AGGREGATED REALITY [ "
+func (visualizer *Visualizer) generateRealityName(realityId RealityId) (result string) {
+	visualizer.ledgerState.GetReality(realityId).Consume(func(object objectstorage.StorableObject) {
+		reality := object.(*Reality)
 
-		realityIdCount := len(realityIds)
-		for id, realityId := range realityIds {
-			if id == realityIdCount-1 {
-				result += strings.Trim(realityId.String(), "\x00")
-			} else {
-				result += strings.Trim(realityId.String(), "\x00") + " + "
-			}
-		}
+		if reality.IsAggregated() {
+			parentConflictRealities := reality.GetParentConflictRealities()
+			realityIdCount := len(parentConflictRealities)
+			counter := 1
+			for realityId, parentConflictReality := range parentConflictRealities {
+				result += visualizer.generateRealityName(realityId)
+
+				if counter != realityIdCount {
+					result += " + "
+				}
 
-		result += " ]"
+				counter++
 
-		return result
-	} else {
-		if realityIds[0] == MAIN_REALITY_ID {
-			return strings.Trim(realityIds[0].String(), "\x00")
+				parentConflictReality.Release()
+			}
+		} else {
+			result = strings.Trim(realityId.String(), "\x00")
 		}
+	})
 
-		return "REALITY [ " + strings.Trim(realityIds[0].String(), "\x00") + " ]"
-	}
+	return
 }
 
 type realityType int